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