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