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 hkbBlendingTransitionEffect<'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: hkbTransitionEffect<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "duration"))]
36 #[cfg_attr(feature = "serde", serde(rename = "duration"))]
37 pub m_duration: f32,
38 #[cfg_attr(
43 feature = "json_schema",
44 schemars(rename = "toGeneratorStartTimeFraction")
45 )]
46 #[cfg_attr(feature = "serde", serde(rename = "toGeneratorStartTimeFraction"))]
47 pub m_toGeneratorStartTimeFraction: f32,
48 #[cfg_attr(feature = "json_schema", schemars(rename = "flags"))]
53 #[cfg_attr(feature = "serde", serde(rename = "flags"))]
54 pub m_flags: FlagBits,
55 #[cfg_attr(feature = "json_schema", schemars(rename = "endMode"))]
60 #[cfg_attr(feature = "serde", serde(rename = "endMode"))]
61 pub m_endMode: EndMode,
62 #[cfg_attr(feature = "json_schema", schemars(rename = "blendCurve"))]
67 #[cfg_attr(feature = "serde", serde(rename = "blendCurve"))]
68 pub m_blendCurve: BlendCurve,
69 #[cfg_attr(feature = "json_schema", schemars(rename = "fromGenerator"))]
75 #[cfg_attr(feature = "serde", serde(rename = "fromGenerator"))]
76 pub m_fromGenerator: Pointer,
77 #[cfg_attr(feature = "json_schema", schemars(rename = "toGenerator"))]
83 #[cfg_attr(feature = "serde", serde(rename = "toGenerator"))]
84 pub m_toGenerator: Pointer,
85 #[cfg_attr(
91 feature = "json_schema",
92 schemars(rename = "characterPoseAtBeginningOfTransition")
93 )]
94 #[cfg_attr(
95 feature = "serde",
96 serde(rename = "characterPoseAtBeginningOfTransition")
97 )]
98 pub m_characterPoseAtBeginningOfTransition: Vec<()>,
99 #[cfg_attr(feature = "json_schema", schemars(rename = "timeRemaining"))]
105 #[cfg_attr(feature = "serde", serde(rename = "timeRemaining"))]
106 pub m_timeRemaining: f32,
107 #[cfg_attr(feature = "json_schema", schemars(rename = "timeInTransition"))]
113 #[cfg_attr(feature = "serde", serde(rename = "timeInTransition"))]
114 pub m_timeInTransition: f32,
115 #[cfg_attr(feature = "json_schema", schemars(rename = "applySelfTransition"))]
121 #[cfg_attr(feature = "serde", serde(rename = "applySelfTransition"))]
122 pub m_applySelfTransition: bool,
123 #[cfg_attr(feature = "json_schema", schemars(rename = "initializeCharacterPose"))]
129 #[cfg_attr(feature = "serde", serde(rename = "initializeCharacterPose"))]
130 pub m_initializeCharacterPose: bool,
131}
132const _: () = {
133 use havok_serde as _serde;
134 impl<'a> _serde::HavokClass for hkbBlendingTransitionEffect<'a> {
135 #[inline]
136 fn name(&self) -> &'static str {
137 "hkbBlendingTransitionEffect"
138 }
139 #[inline]
140 fn signature(&self) -> _serde::__private::Signature {
141 _serde::__private::Signature::new(0xfd8584fe)
142 }
143 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
144 fn deps_indexes(&self) -> Vec<usize> {
145 let mut v = Vec::new();
146 v.push(self.parent.parent.parent.parent.m_variableBindingSet.get());
147 v.push(self.m_fromGenerator.get());
148 v.push(self.m_toGenerator.get());
149 v
150 }
151 }
152 impl<'a> _serde::Serialize for hkbBlendingTransitionEffect<'a> {
153 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
154 where
155 S: _serde::ser::Serializer,
156 {
157 let class_meta = self
158 .__ptr
159 .map(|name| (name, _serde::__private::Signature::new(0xfd8584fe)));
160 let mut serializer = __serializer
161 .serialize_struct(
162 "hkbBlendingTransitionEffect",
163 class_meta,
164 (88u64, 144u64),
165 )?;
166 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
167 serializer
168 .skip_field(
169 "memSizeAndFlags",
170 &self.parent.parent.parent.parent.parent.m_memSizeAndFlags,
171 )?;
172 serializer
173 .skip_field(
174 "referenceCount",
175 &self.parent.parent.parent.parent.parent.m_referenceCount,
176 )?;
177 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
178 serializer
179 .serialize_field(
180 "variableBindingSet",
181 &self.parent.parent.parent.parent.m_variableBindingSet,
182 )?;
183 serializer
184 .skip_array_field(
185 "cachedBindables",
186 &self.parent.parent.parent.parent.m_cachedBindables,
187 TypeSize::NonPtr,
188 )?;
189 serializer
190 .skip_field(
191 "areBindablesCached",
192 &self.parent.parent.parent.parent.m_areBindablesCached,
193 )?;
194 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
195 serializer
196 .serialize_field("userData", &self.parent.parent.parent.m_userData)?;
197 serializer.serialize_field("name", &self.parent.parent.parent.m_name)?;
198 serializer.skip_field("id", &self.parent.parent.parent.m_id)?;
199 serializer
200 .skip_field("cloneState", &self.parent.parent.parent.m_cloneState)?;
201 serializer
202 .skip_fixed_array_field(
203 "padNode",
204 self.parent.parent.parent.m_padNode.as_slice(),
205 TypeSize::NonPtr,
206 )?;
207 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
208 serializer
209 .serialize_field(
210 "selfTransitionMode",
211 &self.parent.m_selfTransitionMode,
212 )?;
213 serializer.serialize_field("eventMode", &self.parent.m_eventMode)?;
214 serializer.skip_field("defaultEventMode", &self.parent.m_defaultEventMode)?;
215 serializer.pad_field([0u8; 1usize].as_slice(), [0u8; 5usize].as_slice())?;
216 serializer.serialize_field("duration", &self.m_duration)?;
217 serializer
218 .serialize_field(
219 "toGeneratorStartTimeFraction",
220 &self.m_toGeneratorStartTimeFraction,
221 )?;
222 serializer.serialize_field("flags", &self.m_flags)?;
223 serializer.serialize_field("endMode", &self.m_endMode)?;
224 serializer.serialize_field("blendCurve", &self.m_blendCurve)?;
225 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
226 serializer.skip_field("fromGenerator", &self.m_fromGenerator)?;
227 serializer.skip_field("toGenerator", &self.m_toGenerator)?;
228 serializer
229 .skip_array_field(
230 "characterPoseAtBeginningOfTransition",
231 &self.m_characterPoseAtBeginningOfTransition,
232 TypeSize::NonPtr,
233 )?;
234 serializer.skip_field("timeRemaining", &self.m_timeRemaining)?;
235 serializer.skip_field("timeInTransition", &self.m_timeInTransition)?;
236 serializer.skip_field("applySelfTransition", &self.m_applySelfTransition)?;
237 serializer
238 .skip_field("initializeCharacterPose", &self.m_initializeCharacterPose)?;
239 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 6usize].as_slice())?;
240 serializer.end()
241 }
242 }
243};
244#[doc(hidden)]
245#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
246const _: () = {
247 use havok_serde as _serde;
248 #[automatically_derived]
249 impl<'de> _serde::Deserialize<'de> for hkbBlendingTransitionEffect<'de> {
250 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
251 where
252 __D: _serde::Deserializer<'de>,
253 {
254 #[allow(non_camel_case_types)]
255 enum __Field {
256 m_variableBindingSet,
257 m_userData,
258 m_name,
259 m_selfTransitionMode,
260 m_eventMode,
261 m_duration,
262 m_toGeneratorStartTimeFraction,
263 m_flags,
264 m_endMode,
265 m_blendCurve,
266 __ignore,
267 }
268 struct __FieldVisitor;
269 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
270 type Value = __Field;
271 fn expecting(
272 &self,
273 __formatter: &mut core::fmt::Formatter,
274 ) -> core::fmt::Result {
275 core::fmt::Formatter::write_str(__formatter, "field identifier")
276 }
277 #[allow(clippy::match_single_binding)]
279 #[allow(clippy::reversed_empty_ranges)]
280 #[allow(clippy::single_match)]
281 fn visit_key<__E>(
282 self,
283 __value: &str,
284 ) -> core::result::Result<Self::Value, __E>
285 where
286 __E: _serde::de::Error,
287 {
288 match __value {
289 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
290 "userData" => Ok(__Field::m_userData),
291 "name" => Ok(__Field::m_name),
292 "selfTransitionMode" => Ok(__Field::m_selfTransitionMode),
293 "eventMode" => Ok(__Field::m_eventMode),
294 "duration" => Ok(__Field::m_duration),
295 "toGeneratorStartTimeFraction" => {
296 Ok(__Field::m_toGeneratorStartTimeFraction)
297 }
298 "flags" => Ok(__Field::m_flags),
299 "endMode" => Ok(__Field::m_endMode),
300 "blendCurve" => Ok(__Field::m_blendCurve),
301 _ => Ok(__Field::__ignore),
302 }
303 }
304 }
305 impl<'de> _serde::Deserialize<'de> for __Field {
306 #[inline]
307 fn deserialize<__D>(
308 __deserializer: __D,
309 ) -> core::result::Result<Self, __D::Error>
310 where
311 __D: _serde::Deserializer<'de>,
312 {
313 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
314 }
315 }
316 struct __hkbBlendingTransitionEffectVisitor<'de> {
317 marker: _serde::__private::PhantomData<hkbBlendingTransitionEffect<'de>>,
318 lifetime: _serde::__private::PhantomData<&'de ()>,
319 }
320 #[allow(clippy::match_single_binding)]
321 #[allow(clippy::reversed_empty_ranges)]
322 #[allow(clippy::single_match)]
323 impl<'de> _serde::de::Visitor<'de>
324 for __hkbBlendingTransitionEffectVisitor<'de> {
325 type Value = hkbBlendingTransitionEffect<'de>;
326 fn expecting(
327 &self,
328 __formatter: &mut core::fmt::Formatter,
329 ) -> core::fmt::Result {
330 core::fmt::Formatter::write_str(
331 __formatter,
332 "struct hkbBlendingTransitionEffect",
333 )
334 }
335 fn visit_struct_for_bytes<__A>(
336 self,
337 mut __map: __A,
338 ) -> _serde::__private::Result<Self::Value, __A::Error>
339 where
340 __A: _serde::de::MapAccess<'de>,
341 {
342 let __ptr = __A::class_ptr(&mut __map);
343 let parent = __A::parent_value(&mut __map)?;
344 let mut m_duration: _serde::__private::Option<f32> = _serde::__private::None;
345 let mut m_toGeneratorStartTimeFraction: _serde::__private::Option<
346 f32,
347 > = _serde::__private::None;
348 let mut m_flags: _serde::__private::Option<FlagBits> = _serde::__private::None;
349 let mut m_endMode: _serde::__private::Option<EndMode> = _serde::__private::None;
350 let mut m_blendCurve: _serde::__private::Option<BlendCurve> = _serde::__private::None;
351 let mut m_fromGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
352 let mut m_toGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
353 let mut m_characterPoseAtBeginningOfTransition: _serde::__private::Option<
354 Vec<()>,
355 > = _serde::__private::None;
356 let mut m_timeRemaining: _serde::__private::Option<f32> = _serde::__private::None;
357 let mut m_timeInTransition: _serde::__private::Option<f32> = _serde::__private::None;
358 let mut m_applySelfTransition: _serde::__private::Option<bool> = _serde::__private::None;
359 let mut m_initializeCharacterPose: _serde::__private::Option<bool> = _serde::__private::None;
360 for i in 0..12usize {
361 match i {
362 0usize => {
363 if _serde::__private::Option::is_some(&m_duration) {
364 return _serde::__private::Err(
365 <__A::Error as _serde::de::Error>::duplicate_field(
366 "duration",
367 ),
368 );
369 }
370 m_duration = _serde::__private::Some(
371 match __A::next_value::<f32>(&mut __map) {
372 _serde::__private::Ok(__val) => __val,
373 _serde::__private::Err(__err) => {
374 return _serde::__private::Err(__err);
375 }
376 },
377 );
378 }
379 1usize => {
380 if _serde::__private::Option::is_some(
381 &m_toGeneratorStartTimeFraction,
382 ) {
383 return _serde::__private::Err(
384 <__A::Error as _serde::de::Error>::duplicate_field(
385 "toGeneratorStartTimeFraction",
386 ),
387 );
388 }
389 m_toGeneratorStartTimeFraction = _serde::__private::Some(
390 match __A::next_value::<f32>(&mut __map) {
391 _serde::__private::Ok(__val) => __val,
392 _serde::__private::Err(__err) => {
393 return _serde::__private::Err(__err);
394 }
395 },
396 );
397 }
398 2usize => {
399 if _serde::__private::Option::is_some(&m_flags) {
400 return _serde::__private::Err(
401 <__A::Error as _serde::de::Error>::duplicate_field("flags"),
402 );
403 }
404 m_flags = _serde::__private::Some(
405 match __A::next_value::<FlagBits>(&mut __map) {
406 _serde::__private::Ok(__val) => __val,
407 _serde::__private::Err(__err) => {
408 return _serde::__private::Err(__err);
409 }
410 },
411 );
412 }
413 3usize => {
414 if _serde::__private::Option::is_some(&m_endMode) {
415 return _serde::__private::Err(
416 <__A::Error as _serde::de::Error>::duplicate_field(
417 "endMode",
418 ),
419 );
420 }
421 m_endMode = _serde::__private::Some(
422 match __A::next_value::<EndMode>(&mut __map) {
423 _serde::__private::Ok(__val) => __val,
424 _serde::__private::Err(__err) => {
425 return _serde::__private::Err(__err);
426 }
427 },
428 );
429 }
430 4usize => {
431 if _serde::__private::Option::is_some(&m_blendCurve) {
432 return _serde::__private::Err(
433 <__A::Error as _serde::de::Error>::duplicate_field(
434 "blendCurve",
435 ),
436 );
437 }
438 m_blendCurve = _serde::__private::Some(
439 match __A::next_value::<BlendCurve>(&mut __map) {
440 _serde::__private::Ok(__val) => __val,
441 _serde::__private::Err(__err) => {
442 return _serde::__private::Err(__err);
443 }
444 },
445 );
446 }
447 5usize => {
448 if _serde::__private::Option::is_some(&m_fromGenerator) {
449 return _serde::__private::Err(
450 <__A::Error as _serde::de::Error>::duplicate_field(
451 "fromGenerator",
452 ),
453 );
454 }
455 __A::pad(&mut __map, 0usize, 4usize)?;
456 m_fromGenerator = _serde::__private::Some(
457 match __A::next_value::<Pointer>(&mut __map) {
458 _serde::__private::Ok(__val) => __val,
459 _serde::__private::Err(__err) => {
460 return _serde::__private::Err(__err);
461 }
462 },
463 );
464 }
465 6usize => {
466 if _serde::__private::Option::is_some(&m_toGenerator) {
467 return _serde::__private::Err(
468 <__A::Error as _serde::de::Error>::duplicate_field(
469 "toGenerator",
470 ),
471 );
472 }
473 m_toGenerator = _serde::__private::Some(
474 match __A::next_value::<Pointer>(&mut __map) {
475 _serde::__private::Ok(__val) => __val,
476 _serde::__private::Err(__err) => {
477 return _serde::__private::Err(__err);
478 }
479 },
480 );
481 }
482 7usize => {
483 if _serde::__private::Option::is_some(
484 &m_characterPoseAtBeginningOfTransition,
485 ) {
486 return _serde::__private::Err(
487 <__A::Error as _serde::de::Error>::duplicate_field(
488 "characterPoseAtBeginningOfTransition",
489 ),
490 );
491 }
492 m_characterPoseAtBeginningOfTransition = _serde::__private::Some(
493 match __A::next_value::<Vec<()>>(&mut __map) {
494 _serde::__private::Ok(__val) => __val,
495 _serde::__private::Err(__err) => {
496 return _serde::__private::Err(__err);
497 }
498 },
499 );
500 }
501 8usize => {
502 if _serde::__private::Option::is_some(&m_timeRemaining) {
503 return _serde::__private::Err(
504 <__A::Error as _serde::de::Error>::duplicate_field(
505 "timeRemaining",
506 ),
507 );
508 }
509 m_timeRemaining = _serde::__private::Some(
510 match __A::next_value::<f32>(&mut __map) {
511 _serde::__private::Ok(__val) => __val,
512 _serde::__private::Err(__err) => {
513 return _serde::__private::Err(__err);
514 }
515 },
516 );
517 }
518 9usize => {
519 if _serde::__private::Option::is_some(&m_timeInTransition) {
520 return _serde::__private::Err(
521 <__A::Error as _serde::de::Error>::duplicate_field(
522 "timeInTransition",
523 ),
524 );
525 }
526 m_timeInTransition = _serde::__private::Some(
527 match __A::next_value::<f32>(&mut __map) {
528 _serde::__private::Ok(__val) => __val,
529 _serde::__private::Err(__err) => {
530 return _serde::__private::Err(__err);
531 }
532 },
533 );
534 }
535 10usize => {
536 if _serde::__private::Option::is_some(
537 &m_applySelfTransition,
538 ) {
539 return _serde::__private::Err(
540 <__A::Error as _serde::de::Error>::duplicate_field(
541 "applySelfTransition",
542 ),
543 );
544 }
545 m_applySelfTransition = _serde::__private::Some(
546 match __A::next_value::<bool>(&mut __map) {
547 _serde::__private::Ok(__val) => __val,
548 _serde::__private::Err(__err) => {
549 return _serde::__private::Err(__err);
550 }
551 },
552 );
553 }
554 11usize => {
555 if _serde::__private::Option::is_some(
556 &m_initializeCharacterPose,
557 ) {
558 return _serde::__private::Err(
559 <__A::Error as _serde::de::Error>::duplicate_field(
560 "initializeCharacterPose",
561 ),
562 );
563 }
564 m_initializeCharacterPose = _serde::__private::Some(
565 match __A::next_value::<bool>(&mut __map) {
566 _serde::__private::Ok(__val) => __val,
567 _serde::__private::Err(__err) => {
568 return _serde::__private::Err(__err);
569 }
570 },
571 );
572 }
573 _ => {}
574 }
575 }
576 __A::pad(&mut __map, 2usize, 6usize)?;
577 let m_duration = match m_duration {
578 _serde::__private::Some(__field) => __field,
579 _serde::__private::None => {
580 return _serde::__private::Err(
581 <__A::Error as _serde::de::Error>::missing_field("duration"),
582 );
583 }
584 };
585 let m_toGeneratorStartTimeFraction = match m_toGeneratorStartTimeFraction {
586 _serde::__private::Some(__field) => __field,
587 _serde::__private::None => {
588 return _serde::__private::Err(
589 <__A::Error as _serde::de::Error>::missing_field(
590 "toGeneratorStartTimeFraction",
591 ),
592 );
593 }
594 };
595 let m_flags = match m_flags {
596 _serde::__private::Some(__field) => __field,
597 _serde::__private::None => {
598 return _serde::__private::Err(
599 <__A::Error as _serde::de::Error>::missing_field("flags"),
600 );
601 }
602 };
603 let m_endMode = match m_endMode {
604 _serde::__private::Some(__field) => __field,
605 _serde::__private::None => {
606 return _serde::__private::Err(
607 <__A::Error as _serde::de::Error>::missing_field("endMode"),
608 );
609 }
610 };
611 let m_blendCurve = match m_blendCurve {
612 _serde::__private::Some(__field) => __field,
613 _serde::__private::None => {
614 return _serde::__private::Err(
615 <__A::Error as _serde::de::Error>::missing_field(
616 "blendCurve",
617 ),
618 );
619 }
620 };
621 let m_fromGenerator = match m_fromGenerator {
622 _serde::__private::Some(__field) => __field,
623 _serde::__private::None => {
624 return _serde::__private::Err(
625 <__A::Error as _serde::de::Error>::missing_field(
626 "fromGenerator",
627 ),
628 );
629 }
630 };
631 let m_toGenerator = match m_toGenerator {
632 _serde::__private::Some(__field) => __field,
633 _serde::__private::None => {
634 return _serde::__private::Err(
635 <__A::Error as _serde::de::Error>::missing_field(
636 "toGenerator",
637 ),
638 );
639 }
640 };
641 let m_characterPoseAtBeginningOfTransition = match m_characterPoseAtBeginningOfTransition {
642 _serde::__private::Some(__field) => __field,
643 _serde::__private::None => {
644 return _serde::__private::Err(
645 <__A::Error as _serde::de::Error>::missing_field(
646 "characterPoseAtBeginningOfTransition",
647 ),
648 );
649 }
650 };
651 let m_timeRemaining = match m_timeRemaining {
652 _serde::__private::Some(__field) => __field,
653 _serde::__private::None => {
654 return _serde::__private::Err(
655 <__A::Error as _serde::de::Error>::missing_field(
656 "timeRemaining",
657 ),
658 );
659 }
660 };
661 let m_timeInTransition = match m_timeInTransition {
662 _serde::__private::Some(__field) => __field,
663 _serde::__private::None => {
664 return _serde::__private::Err(
665 <__A::Error as _serde::de::Error>::missing_field(
666 "timeInTransition",
667 ),
668 );
669 }
670 };
671 let m_applySelfTransition = match m_applySelfTransition {
672 _serde::__private::Some(__field) => __field,
673 _serde::__private::None => {
674 return _serde::__private::Err(
675 <__A::Error as _serde::de::Error>::missing_field(
676 "applySelfTransition",
677 ),
678 );
679 }
680 };
681 let m_initializeCharacterPose = match m_initializeCharacterPose {
682 _serde::__private::Some(__field) => __field,
683 _serde::__private::None => {
684 return _serde::__private::Err(
685 <__A::Error as _serde::de::Error>::missing_field(
686 "initializeCharacterPose",
687 ),
688 );
689 }
690 };
691 _serde::__private::Ok(hkbBlendingTransitionEffect {
692 __ptr,
693 parent,
694 m_duration,
695 m_toGeneratorStartTimeFraction,
696 m_flags,
697 m_endMode,
698 m_blendCurve,
699 m_fromGenerator,
700 m_toGenerator,
701 m_characterPoseAtBeginningOfTransition,
702 m_timeRemaining,
703 m_timeInTransition,
704 m_applySelfTransition,
705 m_initializeCharacterPose,
706 })
707 }
708 #[allow(clippy::manual_unwrap_or_default)]
709 fn visit_struct<__A>(
710 self,
711 mut __map: __A,
712 ) -> _serde::__private::Result<Self::Value, __A::Error>
713 where
714 __A: _serde::de::MapAccess<'de>,
715 {
716 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
717 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
718 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
719 let mut m_selfTransitionMode: _serde::__private::Option<
720 SelfTransitionMode,
721 > = _serde::__private::None;
722 let mut m_eventMode: _serde::__private::Option<EventMode> = _serde::__private::None;
723 let mut m_duration: _serde::__private::Option<f32> = _serde::__private::None;
724 let mut m_toGeneratorStartTimeFraction: _serde::__private::Option<
725 f32,
726 > = _serde::__private::None;
727 let mut m_flags: _serde::__private::Option<FlagBits> = _serde::__private::None;
728 let mut m_endMode: _serde::__private::Option<EndMode> = _serde::__private::None;
729 let mut m_blendCurve: _serde::__private::Option<BlendCurve> = _serde::__private::None;
730 while let _serde::__private::Some(__key) = {
731 __A::next_key::<__Field>(&mut __map)?
732 } {
733 match __key {
734 __Field::m_variableBindingSet => {
735 #[cfg(
736 any(feature = "strict", feature = "ignore_duplicates")
737 )]
738 if _serde::__private::Option::is_some(
739 &m_variableBindingSet,
740 ) {
741 #[cfg(feature = "ignore_duplicates")]
742 {
743 __A::skip_value(&mut __map)?;
744 continue;
745 }
746 #[cfg(feature = "strict")]
747 return _serde::__private::Err(
748 <__A::Error as _serde::de::Error>::duplicate_field(
749 "variableBindingSet",
750 ),
751 );
752 }
753 m_variableBindingSet = _serde::__private::Some(
754 match __A::next_value::<Pointer>(&mut __map) {
755 _serde::__private::Ok(__val) => __val,
756 _serde::__private::Err(__err) => {
757 return _serde::__private::Err(__err);
758 }
759 },
760 );
761 }
762 __Field::m_userData => {
763 #[cfg(
764 any(feature = "strict", feature = "ignore_duplicates")
765 )]
766 if _serde::__private::Option::is_some(&m_userData) {
767 #[cfg(feature = "ignore_duplicates")]
768 {
769 __A::skip_value(&mut __map)?;
770 continue;
771 }
772 #[cfg(feature = "strict")]
773 return _serde::__private::Err(
774 <__A::Error as _serde::de::Error>::duplicate_field(
775 "userData",
776 ),
777 );
778 }
779 m_userData = _serde::__private::Some(
780 match __A::next_value::<Ulong>(&mut __map) {
781 _serde::__private::Ok(__val) => __val,
782 _serde::__private::Err(__err) => {
783 return _serde::__private::Err(__err);
784 }
785 },
786 );
787 }
788 __Field::m_name => {
789 #[cfg(
790 any(feature = "strict", feature = "ignore_duplicates")
791 )]
792 if _serde::__private::Option::is_some(&m_name) {
793 #[cfg(feature = "ignore_duplicates")]
794 {
795 __A::skip_value(&mut __map)?;
796 continue;
797 }
798 #[cfg(feature = "strict")]
799 return _serde::__private::Err(
800 <__A::Error as _serde::de::Error>::duplicate_field("name"),
801 );
802 }
803 m_name = _serde::__private::Some(
804 match __A::next_value::<StringPtr<'de>>(&mut __map) {
805 _serde::__private::Ok(__val) => __val,
806 _serde::__private::Err(__err) => {
807 return _serde::__private::Err(__err);
808 }
809 },
810 );
811 }
812 __Field::m_selfTransitionMode => {
813 #[cfg(
814 any(feature = "strict", feature = "ignore_duplicates")
815 )]
816 if _serde::__private::Option::is_some(
817 &m_selfTransitionMode,
818 ) {
819 #[cfg(feature = "ignore_duplicates")]
820 {
821 __A::skip_value(&mut __map)?;
822 continue;
823 }
824 #[cfg(feature = "strict")]
825 return _serde::__private::Err(
826 <__A::Error as _serde::de::Error>::duplicate_field(
827 "selfTransitionMode",
828 ),
829 );
830 }
831 m_selfTransitionMode = _serde::__private::Some(
832 match __A::next_value::<SelfTransitionMode>(&mut __map) {
833 _serde::__private::Ok(__val) => __val,
834 _serde::__private::Err(__err) => {
835 return _serde::__private::Err(__err);
836 }
837 },
838 );
839 }
840 __Field::m_eventMode => {
841 #[cfg(
842 any(feature = "strict", feature = "ignore_duplicates")
843 )]
844 if _serde::__private::Option::is_some(&m_eventMode) {
845 #[cfg(feature = "ignore_duplicates")]
846 {
847 __A::skip_value(&mut __map)?;
848 continue;
849 }
850 #[cfg(feature = "strict")]
851 return _serde::__private::Err(
852 <__A::Error as _serde::de::Error>::duplicate_field(
853 "eventMode",
854 ),
855 );
856 }
857 m_eventMode = _serde::__private::Some(
858 match __A::next_value::<EventMode>(&mut __map) {
859 _serde::__private::Ok(__val) => __val,
860 _serde::__private::Err(__err) => {
861 return _serde::__private::Err(__err);
862 }
863 },
864 );
865 }
866 __Field::m_duration => {
867 #[cfg(
868 any(feature = "strict", feature = "ignore_duplicates")
869 )]
870 if _serde::__private::Option::is_some(&m_duration) {
871 #[cfg(feature = "ignore_duplicates")]
872 {
873 __A::skip_value(&mut __map)?;
874 continue;
875 }
876 #[cfg(feature = "strict")]
877 return _serde::__private::Err(
878 <__A::Error as _serde::de::Error>::duplicate_field(
879 "duration",
880 ),
881 );
882 }
883 m_duration = _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 __Field::m_toGeneratorStartTimeFraction => {
893 #[cfg(
894 any(feature = "strict", feature = "ignore_duplicates")
895 )]
896 if _serde::__private::Option::is_some(
897 &m_toGeneratorStartTimeFraction,
898 ) {
899 #[cfg(feature = "ignore_duplicates")]
900 {
901 __A::skip_value(&mut __map)?;
902 continue;
903 }
904 #[cfg(feature = "strict")]
905 return _serde::__private::Err(
906 <__A::Error as _serde::de::Error>::duplicate_field(
907 "toGeneratorStartTimeFraction",
908 ),
909 );
910 }
911 m_toGeneratorStartTimeFraction = _serde::__private::Some(
912 match __A::next_value::<f32>(&mut __map) {
913 _serde::__private::Ok(__val) => __val,
914 _serde::__private::Err(__err) => {
915 return _serde::__private::Err(__err);
916 }
917 },
918 );
919 }
920 __Field::m_flags => {
921 #[cfg(
922 any(feature = "strict", feature = "ignore_duplicates")
923 )]
924 if _serde::__private::Option::is_some(&m_flags) {
925 #[cfg(feature = "ignore_duplicates")]
926 {
927 __A::skip_value(&mut __map)?;
928 continue;
929 }
930 #[cfg(feature = "strict")]
931 return _serde::__private::Err(
932 <__A::Error as _serde::de::Error>::duplicate_field("flags"),
933 );
934 }
935 m_flags = _serde::__private::Some(
936 match __A::next_value::<FlagBits>(&mut __map) {
937 _serde::__private::Ok(__val) => __val,
938 _serde::__private::Err(__err) => {
939 return _serde::__private::Err(__err);
940 }
941 },
942 );
943 }
944 __Field::m_endMode => {
945 #[cfg(
946 any(feature = "strict", feature = "ignore_duplicates")
947 )]
948 if _serde::__private::Option::is_some(&m_endMode) {
949 #[cfg(feature = "ignore_duplicates")]
950 {
951 __A::skip_value(&mut __map)?;
952 continue;
953 }
954 #[cfg(feature = "strict")]
955 return _serde::__private::Err(
956 <__A::Error as _serde::de::Error>::duplicate_field(
957 "endMode",
958 ),
959 );
960 }
961 m_endMode = _serde::__private::Some(
962 match __A::next_value::<EndMode>(&mut __map) {
963 _serde::__private::Ok(__val) => __val,
964 _serde::__private::Err(__err) => {
965 return _serde::__private::Err(__err);
966 }
967 },
968 );
969 }
970 __Field::m_blendCurve => {
971 #[cfg(
972 any(feature = "strict", feature = "ignore_duplicates")
973 )]
974 if _serde::__private::Option::is_some(&m_blendCurve) {
975 #[cfg(feature = "ignore_duplicates")]
976 {
977 __A::skip_value(&mut __map)?;
978 continue;
979 }
980 #[cfg(feature = "strict")]
981 return _serde::__private::Err(
982 <__A::Error as _serde::de::Error>::duplicate_field(
983 "blendCurve",
984 ),
985 );
986 }
987 m_blendCurve = _serde::__private::Some(
988 match __A::next_value::<BlendCurve>(&mut __map) {
989 _serde::__private::Ok(__val) => __val,
990 _serde::__private::Err(__err) => {
991 return _serde::__private::Err(__err);
992 }
993 },
994 );
995 }
996 _ => __A::skip_value(&mut __map)?,
997 }
998 }
999 let m_variableBindingSet = match m_variableBindingSet {
1000 _serde::__private::Some(__field) => __field,
1001 _serde::__private::None => {
1002 #[cfg(feature = "strict")]
1003 return _serde::__private::Err(
1004 <__A::Error as _serde::de::Error>::missing_field(
1005 "variableBindingSet",
1006 ),
1007 );
1008 #[cfg(not(feature = "strict"))] Default::default()
1009 }
1010 };
1011 let m_userData = match m_userData {
1012 _serde::__private::Some(__field) => __field,
1013 _serde::__private::None => {
1014 #[cfg(feature = "strict")]
1015 return _serde::__private::Err(
1016 <__A::Error as _serde::de::Error>::missing_field("userData"),
1017 );
1018 #[cfg(not(feature = "strict"))] Default::default()
1019 }
1020 };
1021 let m_name = match m_name {
1022 _serde::__private::Some(__field) => __field,
1023 _serde::__private::None => {
1024 #[cfg(feature = "strict")]
1025 return _serde::__private::Err(
1026 <__A::Error as _serde::de::Error>::missing_field("name"),
1027 );
1028 #[cfg(not(feature = "strict"))] Default::default()
1029 }
1030 };
1031 let m_selfTransitionMode = match m_selfTransitionMode {
1032 _serde::__private::Some(__field) => __field,
1033 _serde::__private::None => {
1034 #[cfg(feature = "strict")]
1035 return _serde::__private::Err(
1036 <__A::Error as _serde::de::Error>::missing_field(
1037 "selfTransitionMode",
1038 ),
1039 );
1040 #[cfg(not(feature = "strict"))] Default::default()
1041 }
1042 };
1043 let m_eventMode = match m_eventMode {
1044 _serde::__private::Some(__field) => __field,
1045 _serde::__private::None => {
1046 #[cfg(feature = "strict")]
1047 return _serde::__private::Err(
1048 <__A::Error as _serde::de::Error>::missing_field(
1049 "eventMode",
1050 ),
1051 );
1052 #[cfg(not(feature = "strict"))] Default::default()
1053 }
1054 };
1055 let m_duration = match m_duration {
1056 _serde::__private::Some(__field) => __field,
1057 _serde::__private::None => {
1058 #[cfg(feature = "strict")]
1059 return _serde::__private::Err(
1060 <__A::Error as _serde::de::Error>::missing_field("duration"),
1061 );
1062 #[cfg(not(feature = "strict"))] Default::default()
1063 }
1064 };
1065 let m_toGeneratorStartTimeFraction = match m_toGeneratorStartTimeFraction {
1066 _serde::__private::Some(__field) => __field,
1067 _serde::__private::None => {
1068 #[cfg(feature = "strict")]
1069 return _serde::__private::Err(
1070 <__A::Error as _serde::de::Error>::missing_field(
1071 "toGeneratorStartTimeFraction",
1072 ),
1073 );
1074 #[cfg(not(feature = "strict"))] Default::default()
1075 }
1076 };
1077 let m_flags = match m_flags {
1078 _serde::__private::Some(__field) => __field,
1079 _serde::__private::None => {
1080 #[cfg(feature = "strict")]
1081 return _serde::__private::Err(
1082 <__A::Error as _serde::de::Error>::missing_field("flags"),
1083 );
1084 #[cfg(not(feature = "strict"))] Default::default()
1085 }
1086 };
1087 let m_endMode = match m_endMode {
1088 _serde::__private::Some(__field) => __field,
1089 _serde::__private::None => {
1090 #[cfg(feature = "strict")]
1091 return _serde::__private::Err(
1092 <__A::Error as _serde::de::Error>::missing_field("endMode"),
1093 );
1094 #[cfg(not(feature = "strict"))] Default::default()
1095 }
1096 };
1097 let m_blendCurve = match m_blendCurve {
1098 _serde::__private::Some(__field) => __field,
1099 _serde::__private::None => {
1100 #[cfg(feature = "strict")]
1101 return _serde::__private::Err(
1102 <__A::Error as _serde::de::Error>::missing_field(
1103 "blendCurve",
1104 ),
1105 );
1106 #[cfg(not(feature = "strict"))] Default::default()
1107 }
1108 };
1109 let __ptr = None;
1110 let parent = hkBaseObject { __ptr };
1111 let parent = hkReferencedObject {
1112 __ptr,
1113 parent,
1114 ..Default::default()
1115 };
1116 let parent = hkbBindable {
1117 __ptr,
1118 parent,
1119 m_variableBindingSet,
1120 ..Default::default()
1121 };
1122 let parent = hkbNode {
1123 __ptr,
1124 parent,
1125 m_userData,
1126 m_name,
1127 ..Default::default()
1128 };
1129 let parent = hkbGenerator { __ptr, parent };
1130 let parent = hkbTransitionEffect {
1131 __ptr,
1132 parent,
1133 m_selfTransitionMode,
1134 m_eventMode,
1135 ..Default::default()
1136 };
1137 let __ptr = __A::class_ptr(&mut __map);
1138 _serde::__private::Ok(hkbBlendingTransitionEffect {
1139 __ptr,
1140 parent,
1141 m_duration,
1142 m_toGeneratorStartTimeFraction,
1143 m_flags,
1144 m_endMode,
1145 m_blendCurve,
1146 ..Default::default()
1147 })
1148 }
1149 }
1150 const FIELDS: &[&str] = &[
1151 "duration",
1152 "toGeneratorStartTimeFraction",
1153 "flags",
1154 "endMode",
1155 "blendCurve",
1156 "fromGenerator",
1157 "toGenerator",
1158 "characterPoseAtBeginningOfTransition",
1159 "timeRemaining",
1160 "timeInTransition",
1161 "applySelfTransition",
1162 "initializeCharacterPose",
1163 ];
1164 _serde::Deserializer::deserialize_struct(
1165 deserializer,
1166 "hkbBlendingTransitionEffect",
1167 FIELDS,
1168 __hkbBlendingTransitionEffectVisitor {
1169 marker: _serde::__private::PhantomData::<
1170 hkbBlendingTransitionEffect,
1171 >,
1172 lifetime: _serde::__private::PhantomData,
1173 },
1174 )
1175 }
1176 }
1177};
1178#[havok_types_derive::impl_flags_methods]
1179bitflags::bitflags! {
1180 #[doc = r" Bit flags"] #[doc = r""] #[doc = r" # C++ Info"] #[doc =
1181 " - name: `FlagBits`(ctype: `hkFlags<FlagBits, hkUint16>`)"]
1182 #[allow(non_upper_case_globals, non_snake_case)] #[cfg_attr(feature = "serde",
1183 derive(serde_with::SerializeDisplay, serde_with::DeserializeFromStr))]
1184 #[repr(transparent)] #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct
1185 FlagBits : u16 { #[doc = "0"] const FLAG_NONE = 0u16; #[doc = "1"] const
1186 FLAG_IGNORE_FROM_WORLD_FROM_MODEL = 1u16; #[doc = "2"] const FLAG_SYNC = 2u16; #[doc
1187 = "4"] const FLAG_IGNORE_TO_WORLD_FROM_MODEL = 4u16; }
1188}
1189#[cfg(feature = "json_schema")]
1190const _: () = {
1191 use schemars::{SchemaGenerator, Schema, JsonSchema, json_schema};
1192 use std::borrow::Cow;
1193 impl JsonSchema for FlagBits {
1194 fn schema_name() -> Cow<'static, str> {
1195 "FlagBits".into()
1196 }
1197 fn schema_id() -> Cow<'static, str> {
1198 concat!(module_path!(), "::", "FlagBits").into()
1199 }
1200 fn json_schema(_generate: &mut SchemaGenerator) -> Schema {
1201 json_schema!(
1202 { "description" :
1203 "Bitflags field. Specific flags: FLAG_NONE: 0, FLAG_IGNORE_FROM_WORLD_FROM_MODEL: 1, FLAG_SYNC: 2, FLAG_IGNORE_TO_WORLD_FROM_MODEL: 4. Additional unspecified bits may be set.(e.g.: BIT_FLAG|BIT_FLAG2|4)",
1204 "type" : "string", }
1205 )
1206 }
1207 }
1208};
1209#[allow(non_upper_case_globals, non_snake_case)]
1212#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1213#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1214#[derive(
1215 Debug,
1216 Clone,
1217 Default,
1218 PartialEq,
1219 Eq,
1220 PartialOrd,
1221 Ord,
1222 num_derive::ToPrimitive,
1223 num_derive::FromPrimitive,
1224)]
1225pub enum EndMode {
1226 #[default]
1227 END_MODE_NONE = 0isize,
1228 END_MODE_TRANSITION_UNTIL_END_OF_FROM_GENERATOR = 1isize,
1229 END_MODE_CAP_DURATION_AT_END_OF_FROM_GENERATOR = 2isize,
1230}
1231const _: () = {
1232 use havok_serde as __serde;
1233 impl __serde::Serialize for FlagBits {
1234 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1235 where
1236 S: __serde::ser::Serializer,
1237 {
1238 let mut __serializer = __serializer.serialize_enum_flags()?;
1239 if self.is_empty() {
1240 __serializer.serialize_bits(&self.bits())?;
1241 __serializer.serialize_empty_bit()?;
1242 return __serializer.end();
1243 }
1244 for flag in self.iter() {
1245 match flag {
1246 Self::FLAG_NONE => {
1247 __serializer.serialize_field("FLAG_NONE", &Self::FLAG_NONE)
1248 }
1249 Self::FLAG_IGNORE_FROM_WORLD_FROM_MODEL => {
1250 __serializer
1251 .serialize_field(
1252 "FLAG_IGNORE_FROM_WORLD_FROM_MODEL",
1253 &Self::FLAG_IGNORE_FROM_WORLD_FROM_MODEL,
1254 )
1255 }
1256 Self::FLAG_SYNC => {
1257 __serializer.serialize_field("FLAG_SYNC", &Self::FLAG_SYNC)
1258 }
1259 Self::FLAG_IGNORE_TO_WORLD_FROM_MODEL => {
1260 __serializer
1261 .serialize_field(
1262 "FLAG_IGNORE_TO_WORLD_FROM_MODEL",
1263 &Self::FLAG_IGNORE_TO_WORLD_FROM_MODEL,
1264 )
1265 }
1266 remain => {
1267 __serializer
1268 .serialize_field(&remain.bits().to_string(), &remain.bits())
1269 }
1270 }?;
1271 }
1272 __serializer.serialize_bits(&self.bits())?;
1273 __serializer.end()
1274 }
1275 }
1276};
1277const _: () = {
1278 use havok_serde as __serde;
1279 impl __serde::Serialize for EndMode {
1280 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1281 where
1282 S: __serde::ser::Serializer,
1283 {
1284 let mut __serializer = __serializer.serialize_enum_flags()?;
1285 match self {
1286 Self::END_MODE_NONE => {
1287 __serializer.serialize_field("END_MODE_NONE", &0u64)
1288 }
1289 Self::END_MODE_TRANSITION_UNTIL_END_OF_FROM_GENERATOR => {
1290 __serializer
1291 .serialize_field(
1292 "END_MODE_TRANSITION_UNTIL_END_OF_FROM_GENERATOR",
1293 &1u64,
1294 )
1295 }
1296 Self::END_MODE_CAP_DURATION_AT_END_OF_FROM_GENERATOR => {
1297 __serializer
1298 .serialize_field(
1299 "END_MODE_CAP_DURATION_AT_END_OF_FROM_GENERATOR",
1300 &2u64,
1301 )
1302 }
1303 }?;
1304 use num_traits::ToPrimitive as _;
1305 let num = self.to_i8().ok_or(S::Error::custom("Failed enum EndMode to_i8"))?;
1306 __serializer.serialize_bits(&num)?;
1307 __serializer.end()
1308 }
1309 }
1310};
1311#[doc(hidden)]
1312#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1313const _: () = {
1314 #[allow(unused_extern_crates, clippy::useless_attribute)]
1315 extern crate havok_serde as _serde;
1316 #[automatically_derived]
1317 impl<'de> _serde::Deserialize<'de> for FlagBits {
1318 fn deserialize<__D>(
1319 __deserializer: __D,
1320 ) -> _serde::__private::Result<Self, __D::Error>
1321 where
1322 __D: _serde::Deserializer<'de>,
1323 {
1324 #[doc(hidden)]
1325 struct __Visitor<'de> {
1326 marker: _serde::__private::PhantomData<FlagBits>,
1327 lifetime: _serde::__private::PhantomData<&'de ()>,
1328 }
1329 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1330 type Value = FlagBits;
1331 fn expecting(
1332 &self,
1333 __formatter: &mut _serde::__private::Formatter,
1334 ) -> _serde::__private::fmt::Result {
1335 _serde::__private::Formatter::write_str(
1336 __formatter,
1337 "struct FlagBits(flags)",
1338 )
1339 }
1340 #[inline]
1341 fn visit_uint16<__E>(
1342 self,
1343 __value: u16,
1344 ) -> _serde::__private::Result<Self::Value, __E>
1345 where
1346 __E: _serde::de::Error,
1347 {
1348 Ok(FlagBits::from_bits_retain(__value as _))
1349 }
1350 fn visit_stringptr<__E>(
1351 self,
1352 __value: StringPtr<'de>,
1353 ) -> _serde::__private::Result<Self::Value, __E>
1354 where
1355 __E: _serde::de::Error,
1356 {
1357 match <FlagBits as core::str::FromStr>::from_str(
1358 __value.into_inner().unwrap().as_ref(),
1359 ) {
1360 Ok(flags) => Ok(flags),
1361 Err(err) => Err(_serde::de::Error::custom(err)),
1362 }
1363 }
1364 }
1365 _serde::Deserializer::deserialize_flags(
1366 __deserializer,
1367 _serde::de::ReadEnumSize::Uint16,
1368 __Visitor {
1369 marker: _serde::__private::PhantomData::<FlagBits>,
1370 lifetime: _serde::__private::PhantomData,
1371 },
1372 )
1373 }
1374 }
1375};
1376#[doc(hidden)]
1377#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1378const _: () = {
1379 #[allow(unused_extern_crates, clippy::useless_attribute)]
1380 extern crate havok_serde as _serde;
1381 #[automatically_derived]
1382 impl<'de> _serde::Deserialize<'de> for EndMode {
1383 fn deserialize<__D>(
1384 __deserializer: __D,
1385 ) -> _serde::__private::Result<Self, __D::Error>
1386 where
1387 __D: _serde::Deserializer<'de>,
1388 {
1389 #[allow(non_camel_case_types)]
1390 #[doc(hidden)]
1391 enum __Field {
1392 __field0,
1393 __field1,
1394 __field2,
1395 }
1396 #[doc(hidden)]
1397 struct __FieldVisitor;
1398 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1399 type Value = __Field;
1400 fn expecting(
1401 &self,
1402 __formatter: &mut _serde::__private::Formatter,
1403 ) -> _serde::__private::fmt::Result {
1404 _serde::__private::Formatter::write_str(
1405 __formatter,
1406 "variant identifier",
1407 )
1408 }
1409 fn visit_int8<__E>(
1410 self,
1411 __value: i8,
1412 ) -> _serde::__private::Result<Self::Value, __E>
1413 where
1414 __E: _serde::de::Error,
1415 {
1416 match __value {
1417 0i8 => _serde::__private::Ok(__Field::__field0),
1418 1i8 => _serde::__private::Ok(__Field::__field1),
1419 2i8 => _serde::__private::Ok(__Field::__field2),
1420 _ => {
1421 _serde::__private::Err(
1422 _serde::de::Error::invalid_value(
1423 _serde::de::Unexpected::Int8(__value),
1424 &"value(i8) of variant is one of 0, 1, 2",
1425 ),
1426 )
1427 }
1428 }
1429 }
1430 fn visit_stringptr<__E>(
1431 self,
1432 __value: StringPtr<'de>,
1433 ) -> _serde::__private::Result<Self::Value, __E>
1434 where
1435 __E: _serde::de::Error,
1436 {
1437 if let Some(__value) = __value.into_inner() {
1438 match __value.as_ref() {
1439 v if v == "0" || v.eq_ignore_ascii_case("END_MODE_NONE") => {
1440 _serde::__private::Ok(__Field::__field0)
1441 }
1442 v if v == "1"
1443 || v
1444 .eq_ignore_ascii_case(
1445 "END_MODE_TRANSITION_UNTIL_END_OF_FROM_GENERATOR",
1446 ) => _serde::__private::Ok(__Field::__field1),
1447 v if v == "2"
1448 || v
1449 .eq_ignore_ascii_case(
1450 "END_MODE_CAP_DURATION_AT_END_OF_FROM_GENERATOR",
1451 ) => _serde::__private::Ok(__Field::__field2),
1452 _ => {
1453 _serde::__private::Err(
1454 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1455 )
1456 }
1457 }
1458 } else {
1459 _serde::__private::Err(
1460 _serde::de::Error::unknown_variant("None", VARIANTS),
1461 )
1462 }
1463 }
1464 }
1465 impl<'de> _serde::Deserialize<'de> for __Field {
1466 #[inline]
1467 fn deserialize<__D>(
1468 __deserializer: __D,
1469 ) -> _serde::__private::Result<Self, __D::Error>
1470 where
1471 __D: _serde::Deserializer<'de>,
1472 {
1473 _serde::Deserializer::deserialize_identifier(
1474 __deserializer,
1475 _serde::de::ReadEnumSize::Int8,
1476 __FieldVisitor,
1477 )
1478 }
1479 }
1480 #[doc(hidden)]
1481 struct __Visitor<'de> {
1482 marker: _serde::__private::PhantomData<EndMode>,
1483 lifetime: _serde::__private::PhantomData<&'de ()>,
1484 }
1485 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1486 type Value = EndMode;
1487 fn expecting(
1488 &self,
1489 __formatter: &mut _serde::__private::Formatter,
1490 ) -> _serde::__private::fmt::Result {
1491 _serde::__private::Formatter::write_str(__formatter, "enum EndMode")
1492 }
1493 fn visit_enum<__A>(
1494 self,
1495 __data: __A,
1496 ) -> _serde::__private::Result<Self::Value, __A::Error>
1497 where
1498 __A: _serde::de::EnumAccess<'de>,
1499 {
1500 match _serde::de::EnumAccess::variant(__data)? {
1501 (__Field::__field0, __variant) => {
1502 _serde::de::VariantAccess::unit_variant(__variant)?;
1503 _serde::__private::Ok(EndMode::END_MODE_NONE)
1504 }
1505 (__Field::__field1, __variant) => {
1506 _serde::de::VariantAccess::unit_variant(__variant)?;
1507 _serde::__private::Ok(
1508 EndMode::END_MODE_TRANSITION_UNTIL_END_OF_FROM_GENERATOR,
1509 )
1510 }
1511 (__Field::__field2, __variant) => {
1512 _serde::de::VariantAccess::unit_variant(__variant)?;
1513 _serde::__private::Ok(
1514 EndMode::END_MODE_CAP_DURATION_AT_END_OF_FROM_GENERATOR,
1515 )
1516 }
1517 }
1518 }
1519 }
1520 #[doc(hidden)]
1521 const VARIANTS: &'static [&'static str] = &[
1522 "END_MODE_NONE",
1523 "END_MODE_TRANSITION_UNTIL_END_OF_FROM_GENERATOR",
1524 "END_MODE_CAP_DURATION_AT_END_OF_FROM_GENERATOR",
1525 ];
1526 _serde::Deserializer::deserialize_enum(
1527 __deserializer,
1528 "EndMode",
1529 VARIANTS,
1530 __Visitor {
1531 marker: _serde::__private::PhantomData::<EndMode>,
1532 lifetime: _serde::__private::PhantomData,
1533 },
1534 )
1535 }
1536 }
1537};