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 hkbWorldFromModelModeData {
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(rename = "poseMatchingBone0"))]
31 #[cfg_attr(feature = "serde", serde(rename = "poseMatchingBone0"))]
32 pub m_poseMatchingBone0: i16,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "poseMatchingBone1"))]
38 #[cfg_attr(feature = "serde", serde(rename = "poseMatchingBone1"))]
39 pub m_poseMatchingBone1: i16,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "poseMatchingBone2"))]
45 #[cfg_attr(feature = "serde", serde(rename = "poseMatchingBone2"))]
46 pub m_poseMatchingBone2: i16,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "mode"))]
52 #[cfg_attr(feature = "serde", serde(rename = "mode"))]
53 pub m_mode: WorldFromModelMode,
54}
55const _: () = {
56 use havok_serde as _serde;
57 impl _serde::HavokClass for hkbWorldFromModelModeData {
58 #[inline]
59 fn name(&self) -> &'static str {
60 "hkbWorldFromModelModeData"
61 }
62 #[inline]
63 fn signature(&self) -> _serde::__private::Signature {
64 _serde::__private::Signature::new(0xa3af8783)
65 }
66 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
67 fn deps_indexes(&self) -> Vec<usize> {
68 let mut v = Vec::new();
69 v
70 }
71 }
72 impl _serde::Serialize for hkbWorldFromModelModeData {
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(0xa3af8783)));
80 let mut serializer = __serializer
81 .serialize_struct(
82 "hkbWorldFromModelModeData",
83 class_meta,
84 (8u64, 8u64),
85 )?;
86 serializer.serialize_field("poseMatchingBone0", &self.m_poseMatchingBone0)?;
87 serializer.serialize_field("poseMatchingBone1", &self.m_poseMatchingBone1)?;
88 serializer.serialize_field("poseMatchingBone2", &self.m_poseMatchingBone2)?;
89 serializer.serialize_field("mode", &self.m_mode)?;
90 serializer.pad_field([0u8; 1usize].as_slice(), [0u8; 1usize].as_slice())?;
91 serializer.end()
92 }
93 }
94};
95#[doc(hidden)]
96#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
97const _: () = {
98 use havok_serde as _serde;
99 #[automatically_derived]
100 impl<'de> _serde::Deserialize<'de> for hkbWorldFromModelModeData {
101 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
102 where
103 __D: _serde::Deserializer<'de>,
104 {
105 #[allow(non_camel_case_types)]
106 enum __Field {
107 m_poseMatchingBone0,
108 m_poseMatchingBone1,
109 m_poseMatchingBone2,
110 m_mode,
111 __ignore,
112 }
113 struct __FieldVisitor;
114 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
115 type Value = __Field;
116 fn expecting(
117 &self,
118 __formatter: &mut core::fmt::Formatter,
119 ) -> core::fmt::Result {
120 core::fmt::Formatter::write_str(__formatter, "field identifier")
121 }
122 #[allow(clippy::match_single_binding)]
124 #[allow(clippy::reversed_empty_ranges)]
125 #[allow(clippy::single_match)]
126 fn visit_key<__E>(
127 self,
128 __value: &str,
129 ) -> core::result::Result<Self::Value, __E>
130 where
131 __E: _serde::de::Error,
132 {
133 match __value {
134 "poseMatchingBone0" => Ok(__Field::m_poseMatchingBone0),
135 "poseMatchingBone1" => Ok(__Field::m_poseMatchingBone1),
136 "poseMatchingBone2" => Ok(__Field::m_poseMatchingBone2),
137 "mode" => Ok(__Field::m_mode),
138 _ => Ok(__Field::__ignore),
139 }
140 }
141 }
142 impl<'de> _serde::Deserialize<'de> for __Field {
143 #[inline]
144 fn deserialize<__D>(
145 __deserializer: __D,
146 ) -> core::result::Result<Self, __D::Error>
147 where
148 __D: _serde::Deserializer<'de>,
149 {
150 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
151 }
152 }
153 struct __hkbWorldFromModelModeDataVisitor<'de> {
154 marker: _serde::__private::PhantomData<hkbWorldFromModelModeData>,
155 lifetime: _serde::__private::PhantomData<&'de ()>,
156 }
157 #[allow(clippy::match_single_binding)]
158 #[allow(clippy::reversed_empty_ranges)]
159 #[allow(clippy::single_match)]
160 impl<'de> _serde::de::Visitor<'de>
161 for __hkbWorldFromModelModeDataVisitor<'de> {
162 type Value = hkbWorldFromModelModeData;
163 fn expecting(
164 &self,
165 __formatter: &mut core::fmt::Formatter,
166 ) -> core::fmt::Result {
167 core::fmt::Formatter::write_str(
168 __formatter,
169 "struct hkbWorldFromModelModeData",
170 )
171 }
172 fn visit_struct_for_bytes<__A>(
173 self,
174 mut __map: __A,
175 ) -> _serde::__private::Result<Self::Value, __A::Error>
176 where
177 __A: _serde::de::MapAccess<'de>,
178 {
179 let __ptr = __A::class_ptr(&mut __map);
180 let mut m_poseMatchingBone0: _serde::__private::Option<i16> = _serde::__private::None;
181 let mut m_poseMatchingBone1: _serde::__private::Option<i16> = _serde::__private::None;
182 let mut m_poseMatchingBone2: _serde::__private::Option<i16> = _serde::__private::None;
183 let mut m_mode: _serde::__private::Option<WorldFromModelMode> = _serde::__private::None;
184 for i in 0..4usize {
185 match i {
186 0usize => {
187 if _serde::__private::Option::is_some(
188 &m_poseMatchingBone0,
189 ) {
190 return _serde::__private::Err(
191 <__A::Error as _serde::de::Error>::duplicate_field(
192 "poseMatchingBone0",
193 ),
194 );
195 }
196 m_poseMatchingBone0 = _serde::__private::Some(
197 match __A::next_value::<i16>(&mut __map) {
198 _serde::__private::Ok(__val) => __val,
199 _serde::__private::Err(__err) => {
200 return _serde::__private::Err(__err);
201 }
202 },
203 );
204 }
205 1usize => {
206 if _serde::__private::Option::is_some(
207 &m_poseMatchingBone1,
208 ) {
209 return _serde::__private::Err(
210 <__A::Error as _serde::de::Error>::duplicate_field(
211 "poseMatchingBone1",
212 ),
213 );
214 }
215 m_poseMatchingBone1 = _serde::__private::Some(
216 match __A::next_value::<i16>(&mut __map) {
217 _serde::__private::Ok(__val) => __val,
218 _serde::__private::Err(__err) => {
219 return _serde::__private::Err(__err);
220 }
221 },
222 );
223 }
224 2usize => {
225 if _serde::__private::Option::is_some(
226 &m_poseMatchingBone2,
227 ) {
228 return _serde::__private::Err(
229 <__A::Error as _serde::de::Error>::duplicate_field(
230 "poseMatchingBone2",
231 ),
232 );
233 }
234 m_poseMatchingBone2 = _serde::__private::Some(
235 match __A::next_value::<i16>(&mut __map) {
236 _serde::__private::Ok(__val) => __val,
237 _serde::__private::Err(__err) => {
238 return _serde::__private::Err(__err);
239 }
240 },
241 );
242 }
243 3usize => {
244 if _serde::__private::Option::is_some(&m_mode) {
245 return _serde::__private::Err(
246 <__A::Error as _serde::de::Error>::duplicate_field("mode"),
247 );
248 }
249 m_mode = _serde::__private::Some(
250 match __A::next_value::<WorldFromModelMode>(&mut __map) {
251 _serde::__private::Ok(__val) => __val,
252 _serde::__private::Err(__err) => {
253 return _serde::__private::Err(__err);
254 }
255 },
256 );
257 }
258 _ => {}
259 }
260 }
261 __A::pad(&mut __map, 1usize, 1usize)?;
262 let m_poseMatchingBone0 = match m_poseMatchingBone0 {
263 _serde::__private::Some(__field) => __field,
264 _serde::__private::None => {
265 return _serde::__private::Err(
266 <__A::Error as _serde::de::Error>::missing_field(
267 "poseMatchingBone0",
268 ),
269 );
270 }
271 };
272 let m_poseMatchingBone1 = match m_poseMatchingBone1 {
273 _serde::__private::Some(__field) => __field,
274 _serde::__private::None => {
275 return _serde::__private::Err(
276 <__A::Error as _serde::de::Error>::missing_field(
277 "poseMatchingBone1",
278 ),
279 );
280 }
281 };
282 let m_poseMatchingBone2 = match m_poseMatchingBone2 {
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 "poseMatchingBone2",
288 ),
289 );
290 }
291 };
292 let m_mode = match m_mode {
293 _serde::__private::Some(__field) => __field,
294 _serde::__private::None => {
295 return _serde::__private::Err(
296 <__A::Error as _serde::de::Error>::missing_field("mode"),
297 );
298 }
299 };
300 _serde::__private::Ok(hkbWorldFromModelModeData {
301 __ptr,
302 m_poseMatchingBone0,
303 m_poseMatchingBone1,
304 m_poseMatchingBone2,
305 m_mode,
306 })
307 }
308 #[allow(clippy::manual_unwrap_or_default)]
309 fn visit_struct<__A>(
310 self,
311 mut __map: __A,
312 ) -> _serde::__private::Result<Self::Value, __A::Error>
313 where
314 __A: _serde::de::MapAccess<'de>,
315 {
316 let mut m_poseMatchingBone0: _serde::__private::Option<i16> = _serde::__private::None;
317 let mut m_poseMatchingBone1: _serde::__private::Option<i16> = _serde::__private::None;
318 let mut m_poseMatchingBone2: _serde::__private::Option<i16> = _serde::__private::None;
319 let mut m_mode: _serde::__private::Option<WorldFromModelMode> = _serde::__private::None;
320 while let _serde::__private::Some(__key) = {
321 __A::next_key::<__Field>(&mut __map)?
322 } {
323 match __key {
324 __Field::m_poseMatchingBone0 => {
325 #[cfg(
326 any(feature = "strict", feature = "ignore_duplicates")
327 )]
328 if _serde::__private::Option::is_some(
329 &m_poseMatchingBone0,
330 ) {
331 #[cfg(feature = "ignore_duplicates")]
332 {
333 __A::skip_value(&mut __map)?;
334 continue;
335 }
336 #[cfg(feature = "strict")]
337 return _serde::__private::Err(
338 <__A::Error as _serde::de::Error>::duplicate_field(
339 "poseMatchingBone0",
340 ),
341 );
342 }
343 m_poseMatchingBone0 = _serde::__private::Some(
344 match __A::next_value::<i16>(&mut __map) {
345 _serde::__private::Ok(__val) => __val,
346 _serde::__private::Err(__err) => {
347 return _serde::__private::Err(__err);
348 }
349 },
350 );
351 }
352 __Field::m_poseMatchingBone1 => {
353 #[cfg(
354 any(feature = "strict", feature = "ignore_duplicates")
355 )]
356 if _serde::__private::Option::is_some(
357 &m_poseMatchingBone1,
358 ) {
359 #[cfg(feature = "ignore_duplicates")]
360 {
361 __A::skip_value(&mut __map)?;
362 continue;
363 }
364 #[cfg(feature = "strict")]
365 return _serde::__private::Err(
366 <__A::Error as _serde::de::Error>::duplicate_field(
367 "poseMatchingBone1",
368 ),
369 );
370 }
371 m_poseMatchingBone1 = _serde::__private::Some(
372 match __A::next_value::<i16>(&mut __map) {
373 _serde::__private::Ok(__val) => __val,
374 _serde::__private::Err(__err) => {
375 return _serde::__private::Err(__err);
376 }
377 },
378 );
379 }
380 __Field::m_poseMatchingBone2 => {
381 #[cfg(
382 any(feature = "strict", feature = "ignore_duplicates")
383 )]
384 if _serde::__private::Option::is_some(
385 &m_poseMatchingBone2,
386 ) {
387 #[cfg(feature = "ignore_duplicates")]
388 {
389 __A::skip_value(&mut __map)?;
390 continue;
391 }
392 #[cfg(feature = "strict")]
393 return _serde::__private::Err(
394 <__A::Error as _serde::de::Error>::duplicate_field(
395 "poseMatchingBone2",
396 ),
397 );
398 }
399 m_poseMatchingBone2 = _serde::__private::Some(
400 match __A::next_value::<i16>(&mut __map) {
401 _serde::__private::Ok(__val) => __val,
402 _serde::__private::Err(__err) => {
403 return _serde::__private::Err(__err);
404 }
405 },
406 );
407 }
408 __Field::m_mode => {
409 #[cfg(
410 any(feature = "strict", feature = "ignore_duplicates")
411 )]
412 if _serde::__private::Option::is_some(&m_mode) {
413 #[cfg(feature = "ignore_duplicates")]
414 {
415 __A::skip_value(&mut __map)?;
416 continue;
417 }
418 #[cfg(feature = "strict")]
419 return _serde::__private::Err(
420 <__A::Error as _serde::de::Error>::duplicate_field("mode"),
421 );
422 }
423 m_mode = _serde::__private::Some(
424 match __A::next_value::<WorldFromModelMode>(&mut __map) {
425 _serde::__private::Ok(__val) => __val,
426 _serde::__private::Err(__err) => {
427 return _serde::__private::Err(__err);
428 }
429 },
430 );
431 }
432 _ => __A::skip_value(&mut __map)?,
433 }
434 }
435 let m_poseMatchingBone0 = match m_poseMatchingBone0 {
436 _serde::__private::Some(__field) => __field,
437 _serde::__private::None => {
438 #[cfg(feature = "strict")]
439 return _serde::__private::Err(
440 <__A::Error as _serde::de::Error>::missing_field(
441 "poseMatchingBone0",
442 ),
443 );
444 #[cfg(not(feature = "strict"))] Default::default()
445 }
446 };
447 let m_poseMatchingBone1 = match m_poseMatchingBone1 {
448 _serde::__private::Some(__field) => __field,
449 _serde::__private::None => {
450 #[cfg(feature = "strict")]
451 return _serde::__private::Err(
452 <__A::Error as _serde::de::Error>::missing_field(
453 "poseMatchingBone1",
454 ),
455 );
456 #[cfg(not(feature = "strict"))] Default::default()
457 }
458 };
459 let m_poseMatchingBone2 = match m_poseMatchingBone2 {
460 _serde::__private::Some(__field) => __field,
461 _serde::__private::None => {
462 #[cfg(feature = "strict")]
463 return _serde::__private::Err(
464 <__A::Error as _serde::de::Error>::missing_field(
465 "poseMatchingBone2",
466 ),
467 );
468 #[cfg(not(feature = "strict"))] Default::default()
469 }
470 };
471 let m_mode = match m_mode {
472 _serde::__private::Some(__field) => __field,
473 _serde::__private::None => {
474 #[cfg(feature = "strict")]
475 return _serde::__private::Err(
476 <__A::Error as _serde::de::Error>::missing_field("mode"),
477 );
478 #[cfg(not(feature = "strict"))] Default::default()
479 }
480 };
481 let __ptr = __A::class_ptr(&mut __map);
482 _serde::__private::Ok(hkbWorldFromModelModeData {
483 __ptr,
484 m_poseMatchingBone0,
485 m_poseMatchingBone1,
486 m_poseMatchingBone2,
487 m_mode,
488 })
489 }
490 }
491 const FIELDS: &[&str] = &[
492 "poseMatchingBone0",
493 "poseMatchingBone1",
494 "poseMatchingBone2",
495 "mode",
496 ];
497 _serde::Deserializer::deserialize_struct(
498 deserializer,
499 "hkbWorldFromModelModeData",
500 FIELDS,
501 __hkbWorldFromModelModeDataVisitor {
502 marker: _serde::__private::PhantomData::<hkbWorldFromModelModeData>,
503 lifetime: _serde::__private::PhantomData,
504 },
505 )
506 }
507 }
508};
509#[allow(non_upper_case_globals, non_snake_case)]
512#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
513#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
514#[derive(
515 Debug,
516 Clone,
517 Default,
518 PartialEq,
519 Eq,
520 PartialOrd,
521 Ord,
522 num_derive::ToPrimitive,
523 num_derive::FromPrimitive,
524)]
525pub enum WorldFromModelMode {
526 #[default]
527 WORLD_FROM_MODEL_MODE_USE_OLD = 0isize,
528 WORLD_FROM_MODEL_MODE_USE_INPUT = 1isize,
529 WORLD_FROM_MODEL_MODE_COMPUTE = 2isize,
530 WORLD_FROM_MODEL_MODE_NONE = 3isize,
531 WORLD_FROM_MODEL_MODE_RAGDOLL = 4isize,
532}
533const _: () = {
534 use havok_serde as __serde;
535 impl __serde::Serialize for WorldFromModelMode {
536 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
537 where
538 S: __serde::ser::Serializer,
539 {
540 let mut __serializer = __serializer.serialize_enum_flags()?;
541 match self {
542 Self::WORLD_FROM_MODEL_MODE_USE_OLD => {
543 __serializer.serialize_field("WORLD_FROM_MODEL_MODE_USE_OLD", &0u64)
544 }
545 Self::WORLD_FROM_MODEL_MODE_USE_INPUT => {
546 __serializer
547 .serialize_field("WORLD_FROM_MODEL_MODE_USE_INPUT", &1u64)
548 }
549 Self::WORLD_FROM_MODEL_MODE_COMPUTE => {
550 __serializer.serialize_field("WORLD_FROM_MODEL_MODE_COMPUTE", &2u64)
551 }
552 Self::WORLD_FROM_MODEL_MODE_NONE => {
553 __serializer.serialize_field("WORLD_FROM_MODEL_MODE_NONE", &3u64)
554 }
555 Self::WORLD_FROM_MODEL_MODE_RAGDOLL => {
556 __serializer.serialize_field("WORLD_FROM_MODEL_MODE_RAGDOLL", &4u64)
557 }
558 }?;
559 use num_traits::ToPrimitive as _;
560 let num = self
561 .to_i8()
562 .ok_or(S::Error::custom("Failed enum WorldFromModelMode to_i8"))?;
563 __serializer.serialize_bits(&num)?;
564 __serializer.end()
565 }
566 }
567};
568#[doc(hidden)]
569#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
570const _: () = {
571 #[allow(unused_extern_crates, clippy::useless_attribute)]
572 extern crate havok_serde as _serde;
573 #[automatically_derived]
574 impl<'de> _serde::Deserialize<'de> for WorldFromModelMode {
575 fn deserialize<__D>(
576 __deserializer: __D,
577 ) -> _serde::__private::Result<Self, __D::Error>
578 where
579 __D: _serde::Deserializer<'de>,
580 {
581 #[allow(non_camel_case_types)]
582 #[doc(hidden)]
583 enum __Field {
584 __field0,
585 __field1,
586 __field2,
587 __field3,
588 __field4,
589 }
590 #[doc(hidden)]
591 struct __FieldVisitor;
592 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
593 type Value = __Field;
594 fn expecting(
595 &self,
596 __formatter: &mut _serde::__private::Formatter,
597 ) -> _serde::__private::fmt::Result {
598 _serde::__private::Formatter::write_str(
599 __formatter,
600 "variant identifier",
601 )
602 }
603 fn visit_int8<__E>(
604 self,
605 __value: i8,
606 ) -> _serde::__private::Result<Self::Value, __E>
607 where
608 __E: _serde::de::Error,
609 {
610 match __value {
611 0i8 => _serde::__private::Ok(__Field::__field0),
612 1i8 => _serde::__private::Ok(__Field::__field1),
613 2i8 => _serde::__private::Ok(__Field::__field2),
614 3i8 => _serde::__private::Ok(__Field::__field3),
615 4i8 => _serde::__private::Ok(__Field::__field4),
616 _ => {
617 _serde::__private::Err(
618 _serde::de::Error::invalid_value(
619 _serde::de::Unexpected::Int8(__value),
620 &"value(i8) of variant is one of 0, 1, 2, 3, 4",
621 ),
622 )
623 }
624 }
625 }
626 fn visit_stringptr<__E>(
627 self,
628 __value: StringPtr<'de>,
629 ) -> _serde::__private::Result<Self::Value, __E>
630 where
631 __E: _serde::de::Error,
632 {
633 if let Some(__value) = __value.into_inner() {
634 match __value.as_ref() {
635 v if v == "0"
636 || v
637 .eq_ignore_ascii_case("WORLD_FROM_MODEL_MODE_USE_OLD") => {
638 _serde::__private::Ok(__Field::__field0)
639 }
640 v if v == "1"
641 || v
642 .eq_ignore_ascii_case("WORLD_FROM_MODEL_MODE_USE_INPUT") => {
643 _serde::__private::Ok(__Field::__field1)
644 }
645 v if v == "2"
646 || v
647 .eq_ignore_ascii_case("WORLD_FROM_MODEL_MODE_COMPUTE") => {
648 _serde::__private::Ok(__Field::__field2)
649 }
650 v if v == "3"
651 || v.eq_ignore_ascii_case("WORLD_FROM_MODEL_MODE_NONE") => {
652 _serde::__private::Ok(__Field::__field3)
653 }
654 v if v == "4"
655 || v
656 .eq_ignore_ascii_case("WORLD_FROM_MODEL_MODE_RAGDOLL") => {
657 _serde::__private::Ok(__Field::__field4)
658 }
659 _ => {
660 _serde::__private::Err(
661 _serde::de::Error::unknown_variant(&__value, VARIANTS),
662 )
663 }
664 }
665 } else {
666 _serde::__private::Err(
667 _serde::de::Error::unknown_variant("None", VARIANTS),
668 )
669 }
670 }
671 }
672 impl<'de> _serde::Deserialize<'de> for __Field {
673 #[inline]
674 fn deserialize<__D>(
675 __deserializer: __D,
676 ) -> _serde::__private::Result<Self, __D::Error>
677 where
678 __D: _serde::Deserializer<'de>,
679 {
680 _serde::Deserializer::deserialize_identifier(
681 __deserializer,
682 _serde::de::ReadEnumSize::Int8,
683 __FieldVisitor,
684 )
685 }
686 }
687 #[doc(hidden)]
688 struct __Visitor<'de> {
689 marker: _serde::__private::PhantomData<WorldFromModelMode>,
690 lifetime: _serde::__private::PhantomData<&'de ()>,
691 }
692 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
693 type Value = WorldFromModelMode;
694 fn expecting(
695 &self,
696 __formatter: &mut _serde::__private::Formatter,
697 ) -> _serde::__private::fmt::Result {
698 _serde::__private::Formatter::write_str(
699 __formatter,
700 "enum WorldFromModelMode",
701 )
702 }
703 fn visit_enum<__A>(
704 self,
705 __data: __A,
706 ) -> _serde::__private::Result<Self::Value, __A::Error>
707 where
708 __A: _serde::de::EnumAccess<'de>,
709 {
710 match _serde::de::EnumAccess::variant(__data)? {
711 (__Field::__field0, __variant) => {
712 _serde::de::VariantAccess::unit_variant(__variant)?;
713 _serde::__private::Ok(
714 WorldFromModelMode::WORLD_FROM_MODEL_MODE_USE_OLD,
715 )
716 }
717 (__Field::__field1, __variant) => {
718 _serde::de::VariantAccess::unit_variant(__variant)?;
719 _serde::__private::Ok(
720 WorldFromModelMode::WORLD_FROM_MODEL_MODE_USE_INPUT,
721 )
722 }
723 (__Field::__field2, __variant) => {
724 _serde::de::VariantAccess::unit_variant(__variant)?;
725 _serde::__private::Ok(
726 WorldFromModelMode::WORLD_FROM_MODEL_MODE_COMPUTE,
727 )
728 }
729 (__Field::__field3, __variant) => {
730 _serde::de::VariantAccess::unit_variant(__variant)?;
731 _serde::__private::Ok(
732 WorldFromModelMode::WORLD_FROM_MODEL_MODE_NONE,
733 )
734 }
735 (__Field::__field4, __variant) => {
736 _serde::de::VariantAccess::unit_variant(__variant)?;
737 _serde::__private::Ok(
738 WorldFromModelMode::WORLD_FROM_MODEL_MODE_RAGDOLL,
739 )
740 }
741 }
742 }
743 }
744 #[doc(hidden)]
745 const VARIANTS: &'static [&'static str] = &[
746 "WORLD_FROM_MODEL_MODE_USE_OLD",
747 "WORLD_FROM_MODEL_MODE_USE_INPUT",
748 "WORLD_FROM_MODEL_MODE_COMPUTE",
749 "WORLD_FROM_MODEL_MODE_NONE",
750 "WORLD_FROM_MODEL_MODE_RAGDOLL",
751 ];
752 _serde::Deserializer::deserialize_enum(
753 __deserializer,
754 "WorldFromModelMode",
755 VARIANTS,
756 __Visitor {
757 marker: _serde::__private::PhantomData::<WorldFromModelMode>,
758 lifetime: _serde::__private::PhantomData,
759 },
760 )
761 }
762 }
763};