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 hkMeshTexture {
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 pub parent: hkReferencedObject,
30}
31const _: () = {
32 use havok_serde as _serde;
33 impl _serde::HavokClass for hkMeshTexture {
34 #[inline]
35 fn name(&self) -> &'static str {
36 "hkMeshTexture"
37 }
38 #[inline]
39 fn signature(&self) -> _serde::__private::Signature {
40 _serde::__private::Signature::new(0xc9887918)
41 }
42 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
43 fn deps_indexes(&self) -> Vec<usize> {
44 let mut v = Vec::new();
45 v
46 }
47 }
48 impl _serde::Serialize for hkMeshTexture {
49 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
50 where
51 S: _serde::ser::Serializer,
52 {
53 let class_meta = self
54 .__ptr
55 .map(|name| (name, _serde::__private::Signature::new(0xc9887918)));
56 let mut serializer = __serializer
57 .serialize_struct("hkMeshTexture", class_meta, (8u64, 16u64))?;
58 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
59 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
60 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
61 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
62 serializer.end()
63 }
64 }
65};
66#[doc(hidden)]
67#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
68const _: () = {
69 use havok_serde as _serde;
70 #[automatically_derived]
71 impl<'de> _serde::Deserialize<'de> for hkMeshTexture {
72 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
73 where
74 __D: _serde::Deserializer<'de>,
75 {
76 #[allow(non_camel_case_types)]
77 enum __Field {
78 __ignore,
79 }
80 struct __FieldVisitor;
81 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
82 type Value = __Field;
83 fn expecting(
84 &self,
85 __formatter: &mut core::fmt::Formatter,
86 ) -> core::fmt::Result {
87 core::fmt::Formatter::write_str(__formatter, "field identifier")
88 }
89 #[allow(clippy::match_single_binding)]
91 #[allow(clippy::reversed_empty_ranges)]
92 #[allow(clippy::single_match)]
93 fn visit_key<__E>(
94 self,
95 __value: &str,
96 ) -> core::result::Result<Self::Value, __E>
97 where
98 __E: _serde::de::Error,
99 {
100 match __value {
101 _ => Ok(__Field::__ignore),
102 }
103 }
104 }
105 impl<'de> _serde::Deserialize<'de> for __Field {
106 #[inline]
107 fn deserialize<__D>(
108 __deserializer: __D,
109 ) -> core::result::Result<Self, __D::Error>
110 where
111 __D: _serde::Deserializer<'de>,
112 {
113 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
114 }
115 }
116 struct __hkMeshTextureVisitor<'de> {
117 marker: _serde::__private::PhantomData<hkMeshTexture>,
118 lifetime: _serde::__private::PhantomData<&'de ()>,
119 }
120 #[allow(clippy::match_single_binding)]
121 #[allow(clippy::reversed_empty_ranges)]
122 #[allow(clippy::single_match)]
123 impl<'de> _serde::de::Visitor<'de> for __hkMeshTextureVisitor<'de> {
124 type Value = hkMeshTexture;
125 fn expecting(
126 &self,
127 __formatter: &mut core::fmt::Formatter,
128 ) -> core::fmt::Result {
129 core::fmt::Formatter::write_str(__formatter, "struct hkMeshTexture")
130 }
131 fn visit_struct_for_bytes<__A>(
132 self,
133 mut __map: __A,
134 ) -> _serde::__private::Result<Self::Value, __A::Error>
135 where
136 __A: _serde::de::MapAccess<'de>,
137 {
138 let __ptr = __A::class_ptr(&mut __map);
139 let parent = __A::parent_value(&mut __map)?;
140 for i in 0..0usize {
141 match i {
142 _ => {}
143 }
144 }
145 _serde::__private::Ok(hkMeshTexture { __ptr, parent })
146 }
147 #[allow(clippy::manual_unwrap_or_default)]
148 fn visit_struct<__A>(
149 self,
150 mut __map: __A,
151 ) -> _serde::__private::Result<Self::Value, __A::Error>
152 where
153 __A: _serde::de::MapAccess<'de>,
154 {
155 while let _serde::__private::Some(__key) = {
156 __A::next_key::<__Field>(&mut __map)?
157 } {
158 match __key {
159 _ => __A::skip_value(&mut __map)?,
160 }
161 }
162 let __ptr = None;
163 let parent = hkBaseObject { __ptr };
164 let parent = hkReferencedObject {
165 __ptr,
166 parent,
167 ..Default::default()
168 };
169 let __ptr = __A::class_ptr(&mut __map);
170 _serde::__private::Ok(hkMeshTexture { __ptr, parent })
171 }
172 }
173 const FIELDS: &[&str] = &[];
174 _serde::Deserializer::deserialize_struct(
175 deserializer,
176 "hkMeshTexture",
177 FIELDS,
178 __hkMeshTextureVisitor {
179 marker: _serde::__private::PhantomData::<hkMeshTexture>,
180 lifetime: _serde::__private::PhantomData,
181 },
182 )
183 }
184 }
185};
186#[allow(non_upper_case_globals, non_snake_case)]
189#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
190#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
191#[derive(
192 Debug,
193 Clone,
194 Default,
195 PartialEq,
196 Eq,
197 PartialOrd,
198 Ord,
199 num_derive::ToPrimitive,
200 num_derive::FromPrimitive,
201)]
202pub enum Format {
203 #[default]
204 Unknown = 0isize,
205 PNG = 1isize,
206 TGA = 2isize,
207 BMP = 3isize,
208 DDS = 4isize,
209}
210#[allow(non_upper_case_globals, non_snake_case)]
213#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
214#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
215#[derive(
216 Debug,
217 Clone,
218 Default,
219 PartialEq,
220 Eq,
221 PartialOrd,
222 Ord,
223 num_derive::ToPrimitive,
224 num_derive::FromPrimitive,
225)]
226pub enum FilterMode {
227 #[default]
228 POINT = 0isize,
229 LINEAR = 1isize,
230 ANISOTROPIC = 2isize,
231}
232#[allow(non_upper_case_globals, non_snake_case)]
235#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
236#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
237#[derive(
238 Debug,
239 Clone,
240 Default,
241 PartialEq,
242 Eq,
243 PartialOrd,
244 Ord,
245 num_derive::ToPrimitive,
246 num_derive::FromPrimitive,
247)]
248pub enum TextureUsageType {
249 #[default]
250 UNKNOWN = 0isize,
251 DIFFUSE = 1isize,
252 REFLECTION = 2isize,
253 BUMP = 3isize,
254 NORMAL = 4isize,
255 DISPLACEMENT = 5isize,
256 SPECULAR = 6isize,
257 SPECULARANDGLOSS = 7isize,
258 OPACITY = 8isize,
259 EMISSIVE = 9isize,
260 REFRACTION = 10isize,
261 GLOSS = 11isize,
262 NOTEXPORTED = 12isize,
263}
264const _: () = {
265 use havok_serde as __serde;
266 impl __serde::Serialize for Format {
267 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
268 where
269 S: __serde::ser::Serializer,
270 {
271 let mut __serializer = __serializer.serialize_enum_flags()?;
272 match self {
273 Self::Unknown => __serializer.serialize_field("Unknown", &0u64),
274 Self::PNG => __serializer.serialize_field("PNG", &1u64),
275 Self::TGA => __serializer.serialize_field("TGA", &2u64),
276 Self::BMP => __serializer.serialize_field("BMP", &3u64),
277 Self::DDS => __serializer.serialize_field("DDS", &4u64),
278 }?;
279 use num_traits::ToPrimitive as _;
280 let num = self.to_i8().ok_or(S::Error::custom("Failed enum Format to_i8"))?;
281 __serializer.serialize_bits(&num)?;
282 __serializer.end()
283 }
284 }
285};
286const _: () = {
287 use havok_serde as __serde;
288 impl __serde::Serialize for FilterMode {
289 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
290 where
291 S: __serde::ser::Serializer,
292 {
293 let mut __serializer = __serializer.serialize_enum_flags()?;
294 match self {
295 Self::POINT => __serializer.serialize_field("POINT", &0u64),
296 Self::LINEAR => __serializer.serialize_field("LINEAR", &1u64),
297 Self::ANISOTROPIC => __serializer.serialize_field("ANISOTROPIC", &2u64),
298 }?;
299 use num_traits::ToPrimitive as _;
300 let num = self
301 .to_i8()
302 .ok_or(S::Error::custom("Failed enum FilterMode to_i8"))?;
303 __serializer.serialize_bits(&num)?;
304 __serializer.end()
305 }
306 }
307};
308const _: () = {
309 use havok_serde as __serde;
310 impl __serde::Serialize for TextureUsageType {
311 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
312 where
313 S: __serde::ser::Serializer,
314 {
315 let mut __serializer = __serializer.serialize_enum_flags()?;
316 match self {
317 Self::UNKNOWN => __serializer.serialize_field("UNKNOWN", &0u64),
318 Self::DIFFUSE => __serializer.serialize_field("DIFFUSE", &1u64),
319 Self::REFLECTION => __serializer.serialize_field("REFLECTION", &2u64),
320 Self::BUMP => __serializer.serialize_field("BUMP", &3u64),
321 Self::NORMAL => __serializer.serialize_field("NORMAL", &4u64),
322 Self::DISPLACEMENT => __serializer.serialize_field("DISPLACEMENT", &5u64),
323 Self::SPECULAR => __serializer.serialize_field("SPECULAR", &6u64),
324 Self::SPECULARANDGLOSS => {
325 __serializer.serialize_field("SPECULARANDGLOSS", &7u64)
326 }
327 Self::OPACITY => __serializer.serialize_field("OPACITY", &8u64),
328 Self::EMISSIVE => __serializer.serialize_field("EMISSIVE", &9u64),
329 Self::REFRACTION => __serializer.serialize_field("REFRACTION", &10u64),
330 Self::GLOSS => __serializer.serialize_field("GLOSS", &11u64),
331 Self::NOTEXPORTED => __serializer.serialize_field("NOTEXPORTED", &12u64),
332 }?;
333 use num_traits::ToPrimitive as _;
334 let num = self
335 .to_i8()
336 .ok_or(S::Error::custom("Failed enum TextureUsageType to_i8"))?;
337 __serializer.serialize_bits(&num)?;
338 __serializer.end()
339 }
340 }
341};
342#[doc(hidden)]
343#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
344const _: () = {
345 #[allow(unused_extern_crates, clippy::useless_attribute)]
346 extern crate havok_serde as _serde;
347 #[automatically_derived]
348 impl<'de> _serde::Deserialize<'de> for Format {
349 fn deserialize<__D>(
350 __deserializer: __D,
351 ) -> _serde::__private::Result<Self, __D::Error>
352 where
353 __D: _serde::Deserializer<'de>,
354 {
355 #[allow(non_camel_case_types)]
356 #[doc(hidden)]
357 enum __Field {
358 __field0,
359 __field1,
360 __field2,
361 __field3,
362 __field4,
363 }
364 #[doc(hidden)]
365 struct __FieldVisitor;
366 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
367 type Value = __Field;
368 fn expecting(
369 &self,
370 __formatter: &mut _serde::__private::Formatter,
371 ) -> _serde::__private::fmt::Result {
372 _serde::__private::Formatter::write_str(
373 __formatter,
374 "variant identifier",
375 )
376 }
377 fn visit_int8<__E>(
378 self,
379 __value: i8,
380 ) -> _serde::__private::Result<Self::Value, __E>
381 where
382 __E: _serde::de::Error,
383 {
384 match __value {
385 0i8 => _serde::__private::Ok(__Field::__field0),
386 1i8 => _serde::__private::Ok(__Field::__field1),
387 2i8 => _serde::__private::Ok(__Field::__field2),
388 3i8 => _serde::__private::Ok(__Field::__field3),
389 4i8 => _serde::__private::Ok(__Field::__field4),
390 _ => {
391 _serde::__private::Err(
392 _serde::de::Error::invalid_value(
393 _serde::de::Unexpected::Int8(__value),
394 &"value(i8) of variant is one of 0, 1, 2, 3, 4",
395 ),
396 )
397 }
398 }
399 }
400 fn visit_stringptr<__E>(
401 self,
402 __value: StringPtr<'de>,
403 ) -> _serde::__private::Result<Self::Value, __E>
404 where
405 __E: _serde::de::Error,
406 {
407 if let Some(__value) = __value.into_inner() {
408 match __value.as_ref() {
409 v if v == "0" || v.eq_ignore_ascii_case("Unknown") => {
410 _serde::__private::Ok(__Field::__field0)
411 }
412 v if v == "1" || v.eq_ignore_ascii_case("PNG") => {
413 _serde::__private::Ok(__Field::__field1)
414 }
415 v if v == "2" || v.eq_ignore_ascii_case("TGA") => {
416 _serde::__private::Ok(__Field::__field2)
417 }
418 v if v == "3" || v.eq_ignore_ascii_case("BMP") => {
419 _serde::__private::Ok(__Field::__field3)
420 }
421 v if v == "4" || v.eq_ignore_ascii_case("DDS") => {
422 _serde::__private::Ok(__Field::__field4)
423 }
424 _ => {
425 _serde::__private::Err(
426 _serde::de::Error::unknown_variant(&__value, VARIANTS),
427 )
428 }
429 }
430 } else {
431 _serde::__private::Err(
432 _serde::de::Error::unknown_variant("None", VARIANTS),
433 )
434 }
435 }
436 }
437 impl<'de> _serde::Deserialize<'de> for __Field {
438 #[inline]
439 fn deserialize<__D>(
440 __deserializer: __D,
441 ) -> _serde::__private::Result<Self, __D::Error>
442 where
443 __D: _serde::Deserializer<'de>,
444 {
445 _serde::Deserializer::deserialize_identifier(
446 __deserializer,
447 _serde::de::ReadEnumSize::Int8,
448 __FieldVisitor,
449 )
450 }
451 }
452 #[doc(hidden)]
453 struct __Visitor<'de> {
454 marker: _serde::__private::PhantomData<Format>,
455 lifetime: _serde::__private::PhantomData<&'de ()>,
456 }
457 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
458 type Value = Format;
459 fn expecting(
460 &self,
461 __formatter: &mut _serde::__private::Formatter,
462 ) -> _serde::__private::fmt::Result {
463 _serde::__private::Formatter::write_str(__formatter, "enum Format")
464 }
465 fn visit_enum<__A>(
466 self,
467 __data: __A,
468 ) -> _serde::__private::Result<Self::Value, __A::Error>
469 where
470 __A: _serde::de::EnumAccess<'de>,
471 {
472 match _serde::de::EnumAccess::variant(__data)? {
473 (__Field::__field0, __variant) => {
474 _serde::de::VariantAccess::unit_variant(__variant)?;
475 _serde::__private::Ok(Format::Unknown)
476 }
477 (__Field::__field1, __variant) => {
478 _serde::de::VariantAccess::unit_variant(__variant)?;
479 _serde::__private::Ok(Format::PNG)
480 }
481 (__Field::__field2, __variant) => {
482 _serde::de::VariantAccess::unit_variant(__variant)?;
483 _serde::__private::Ok(Format::TGA)
484 }
485 (__Field::__field3, __variant) => {
486 _serde::de::VariantAccess::unit_variant(__variant)?;
487 _serde::__private::Ok(Format::BMP)
488 }
489 (__Field::__field4, __variant) => {
490 _serde::de::VariantAccess::unit_variant(__variant)?;
491 _serde::__private::Ok(Format::DDS)
492 }
493 }
494 }
495 }
496 #[doc(hidden)]
497 const VARIANTS: &'static [&'static str] = &[
498 "Unknown",
499 "PNG",
500 "TGA",
501 "BMP",
502 "DDS",
503 ];
504 _serde::Deserializer::deserialize_enum(
505 __deserializer,
506 "Format",
507 VARIANTS,
508 __Visitor {
509 marker: _serde::__private::PhantomData::<Format>,
510 lifetime: _serde::__private::PhantomData,
511 },
512 )
513 }
514 }
515};
516#[doc(hidden)]
517#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
518const _: () = {
519 #[allow(unused_extern_crates, clippy::useless_attribute)]
520 extern crate havok_serde as _serde;
521 #[automatically_derived]
522 impl<'de> _serde::Deserialize<'de> for FilterMode {
523 fn deserialize<__D>(
524 __deserializer: __D,
525 ) -> _serde::__private::Result<Self, __D::Error>
526 where
527 __D: _serde::Deserializer<'de>,
528 {
529 #[allow(non_camel_case_types)]
530 #[doc(hidden)]
531 enum __Field {
532 __field0,
533 __field1,
534 __field2,
535 }
536 #[doc(hidden)]
537 struct __FieldVisitor;
538 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
539 type Value = __Field;
540 fn expecting(
541 &self,
542 __formatter: &mut _serde::__private::Formatter,
543 ) -> _serde::__private::fmt::Result {
544 _serde::__private::Formatter::write_str(
545 __formatter,
546 "variant identifier",
547 )
548 }
549 fn visit_int8<__E>(
550 self,
551 __value: i8,
552 ) -> _serde::__private::Result<Self::Value, __E>
553 where
554 __E: _serde::de::Error,
555 {
556 match __value {
557 0i8 => _serde::__private::Ok(__Field::__field0),
558 1i8 => _serde::__private::Ok(__Field::__field1),
559 2i8 => _serde::__private::Ok(__Field::__field2),
560 _ => {
561 _serde::__private::Err(
562 _serde::de::Error::invalid_value(
563 _serde::de::Unexpected::Int8(__value),
564 &"value(i8) of variant is one of 0, 1, 2",
565 ),
566 )
567 }
568 }
569 }
570 fn visit_stringptr<__E>(
571 self,
572 __value: StringPtr<'de>,
573 ) -> _serde::__private::Result<Self::Value, __E>
574 where
575 __E: _serde::de::Error,
576 {
577 if let Some(__value) = __value.into_inner() {
578 match __value.as_ref() {
579 v if v == "0" || v.eq_ignore_ascii_case("POINT") => {
580 _serde::__private::Ok(__Field::__field0)
581 }
582 v if v == "1" || v.eq_ignore_ascii_case("LINEAR") => {
583 _serde::__private::Ok(__Field::__field1)
584 }
585 v if v == "2" || v.eq_ignore_ascii_case("ANISOTROPIC") => {
586 _serde::__private::Ok(__Field::__field2)
587 }
588 _ => {
589 _serde::__private::Err(
590 _serde::de::Error::unknown_variant(&__value, VARIANTS),
591 )
592 }
593 }
594 } else {
595 _serde::__private::Err(
596 _serde::de::Error::unknown_variant("None", VARIANTS),
597 )
598 }
599 }
600 }
601 impl<'de> _serde::Deserialize<'de> for __Field {
602 #[inline]
603 fn deserialize<__D>(
604 __deserializer: __D,
605 ) -> _serde::__private::Result<Self, __D::Error>
606 where
607 __D: _serde::Deserializer<'de>,
608 {
609 _serde::Deserializer::deserialize_identifier(
610 __deserializer,
611 _serde::de::ReadEnumSize::Int8,
612 __FieldVisitor,
613 )
614 }
615 }
616 #[doc(hidden)]
617 struct __Visitor<'de> {
618 marker: _serde::__private::PhantomData<FilterMode>,
619 lifetime: _serde::__private::PhantomData<&'de ()>,
620 }
621 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
622 type Value = FilterMode;
623 fn expecting(
624 &self,
625 __formatter: &mut _serde::__private::Formatter,
626 ) -> _serde::__private::fmt::Result {
627 _serde::__private::Formatter::write_str(
628 __formatter,
629 "enum FilterMode",
630 )
631 }
632 fn visit_enum<__A>(
633 self,
634 __data: __A,
635 ) -> _serde::__private::Result<Self::Value, __A::Error>
636 where
637 __A: _serde::de::EnumAccess<'de>,
638 {
639 match _serde::de::EnumAccess::variant(__data)? {
640 (__Field::__field0, __variant) => {
641 _serde::de::VariantAccess::unit_variant(__variant)?;
642 _serde::__private::Ok(FilterMode::POINT)
643 }
644 (__Field::__field1, __variant) => {
645 _serde::de::VariantAccess::unit_variant(__variant)?;
646 _serde::__private::Ok(FilterMode::LINEAR)
647 }
648 (__Field::__field2, __variant) => {
649 _serde::de::VariantAccess::unit_variant(__variant)?;
650 _serde::__private::Ok(FilterMode::ANISOTROPIC)
651 }
652 }
653 }
654 }
655 #[doc(hidden)]
656 const VARIANTS: &'static [&'static str] = &[
657 "POINT",
658 "LINEAR",
659 "ANISOTROPIC",
660 ];
661 _serde::Deserializer::deserialize_enum(
662 __deserializer,
663 "FilterMode",
664 VARIANTS,
665 __Visitor {
666 marker: _serde::__private::PhantomData::<FilterMode>,
667 lifetime: _serde::__private::PhantomData,
668 },
669 )
670 }
671 }
672};
673#[doc(hidden)]
674#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
675const _: () = {
676 #[allow(unused_extern_crates, clippy::useless_attribute)]
677 extern crate havok_serde as _serde;
678 #[automatically_derived]
679 impl<'de> _serde::Deserialize<'de> for TextureUsageType {
680 fn deserialize<__D>(
681 __deserializer: __D,
682 ) -> _serde::__private::Result<Self, __D::Error>
683 where
684 __D: _serde::Deserializer<'de>,
685 {
686 #[allow(non_camel_case_types)]
687 #[doc(hidden)]
688 enum __Field {
689 __field0,
690 __field1,
691 __field2,
692 __field3,
693 __field4,
694 __field5,
695 __field6,
696 __field7,
697 __field8,
698 __field9,
699 __field10,
700 __field11,
701 __field12,
702 }
703 #[doc(hidden)]
704 struct __FieldVisitor;
705 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
706 type Value = __Field;
707 fn expecting(
708 &self,
709 __formatter: &mut _serde::__private::Formatter,
710 ) -> _serde::__private::fmt::Result {
711 _serde::__private::Formatter::write_str(
712 __formatter,
713 "variant identifier",
714 )
715 }
716 fn visit_int8<__E>(
717 self,
718 __value: i8,
719 ) -> _serde::__private::Result<Self::Value, __E>
720 where
721 __E: _serde::de::Error,
722 {
723 match __value {
724 0i8 => _serde::__private::Ok(__Field::__field0),
725 1i8 => _serde::__private::Ok(__Field::__field1),
726 2i8 => _serde::__private::Ok(__Field::__field2),
727 3i8 => _serde::__private::Ok(__Field::__field3),
728 4i8 => _serde::__private::Ok(__Field::__field4),
729 5i8 => _serde::__private::Ok(__Field::__field5),
730 6i8 => _serde::__private::Ok(__Field::__field6),
731 7i8 => _serde::__private::Ok(__Field::__field7),
732 8i8 => _serde::__private::Ok(__Field::__field8),
733 9i8 => _serde::__private::Ok(__Field::__field9),
734 10i8 => _serde::__private::Ok(__Field::__field10),
735 11i8 => _serde::__private::Ok(__Field::__field11),
736 12i8 => _serde::__private::Ok(__Field::__field12),
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, 4, 5, 6, 7, 8, 9, 10, 11, 12",
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" || v.eq_ignore_ascii_case("UNKNOWN") => {
757 _serde::__private::Ok(__Field::__field0)
758 }
759 v if v == "1" || v.eq_ignore_ascii_case("DIFFUSE") => {
760 _serde::__private::Ok(__Field::__field1)
761 }
762 v if v == "2" || v.eq_ignore_ascii_case("REFLECTION") => {
763 _serde::__private::Ok(__Field::__field2)
764 }
765 v if v == "3" || v.eq_ignore_ascii_case("BUMP") => {
766 _serde::__private::Ok(__Field::__field3)
767 }
768 v if v == "4" || v.eq_ignore_ascii_case("NORMAL") => {
769 _serde::__private::Ok(__Field::__field4)
770 }
771 v if v == "5" || v.eq_ignore_ascii_case("DISPLACEMENT") => {
772 _serde::__private::Ok(__Field::__field5)
773 }
774 v if v == "6" || v.eq_ignore_ascii_case("SPECULAR") => {
775 _serde::__private::Ok(__Field::__field6)
776 }
777 v if v == "7"
778 || v.eq_ignore_ascii_case("SPECULARANDGLOSS") => {
779 _serde::__private::Ok(__Field::__field7)
780 }
781 v if v == "8" || v.eq_ignore_ascii_case("OPACITY") => {
782 _serde::__private::Ok(__Field::__field8)
783 }
784 v if v == "9" || v.eq_ignore_ascii_case("EMISSIVE") => {
785 _serde::__private::Ok(__Field::__field9)
786 }
787 v if v == "10" || v.eq_ignore_ascii_case("REFRACTION") => {
788 _serde::__private::Ok(__Field::__field10)
789 }
790 v if v == "11" || v.eq_ignore_ascii_case("GLOSS") => {
791 _serde::__private::Ok(__Field::__field11)
792 }
793 v if v == "12" || v.eq_ignore_ascii_case("NOTEXPORTED") => {
794 _serde::__private::Ok(__Field::__field12)
795 }
796 _ => {
797 _serde::__private::Err(
798 _serde::de::Error::unknown_variant(&__value, VARIANTS),
799 )
800 }
801 }
802 } else {
803 _serde::__private::Err(
804 _serde::de::Error::unknown_variant("None", VARIANTS),
805 )
806 }
807 }
808 }
809 impl<'de> _serde::Deserialize<'de> for __Field {
810 #[inline]
811 fn deserialize<__D>(
812 __deserializer: __D,
813 ) -> _serde::__private::Result<Self, __D::Error>
814 where
815 __D: _serde::Deserializer<'de>,
816 {
817 _serde::Deserializer::deserialize_identifier(
818 __deserializer,
819 _serde::de::ReadEnumSize::Int8,
820 __FieldVisitor,
821 )
822 }
823 }
824 #[doc(hidden)]
825 struct __Visitor<'de> {
826 marker: _serde::__private::PhantomData<TextureUsageType>,
827 lifetime: _serde::__private::PhantomData<&'de ()>,
828 }
829 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
830 type Value = TextureUsageType;
831 fn expecting(
832 &self,
833 __formatter: &mut _serde::__private::Formatter,
834 ) -> _serde::__private::fmt::Result {
835 _serde::__private::Formatter::write_str(
836 __formatter,
837 "enum TextureUsageType",
838 )
839 }
840 fn visit_enum<__A>(
841 self,
842 __data: __A,
843 ) -> _serde::__private::Result<Self::Value, __A::Error>
844 where
845 __A: _serde::de::EnumAccess<'de>,
846 {
847 match _serde::de::EnumAccess::variant(__data)? {
848 (__Field::__field0, __variant) => {
849 _serde::de::VariantAccess::unit_variant(__variant)?;
850 _serde::__private::Ok(TextureUsageType::UNKNOWN)
851 }
852 (__Field::__field1, __variant) => {
853 _serde::de::VariantAccess::unit_variant(__variant)?;
854 _serde::__private::Ok(TextureUsageType::DIFFUSE)
855 }
856 (__Field::__field2, __variant) => {
857 _serde::de::VariantAccess::unit_variant(__variant)?;
858 _serde::__private::Ok(TextureUsageType::REFLECTION)
859 }
860 (__Field::__field3, __variant) => {
861 _serde::de::VariantAccess::unit_variant(__variant)?;
862 _serde::__private::Ok(TextureUsageType::BUMP)
863 }
864 (__Field::__field4, __variant) => {
865 _serde::de::VariantAccess::unit_variant(__variant)?;
866 _serde::__private::Ok(TextureUsageType::NORMAL)
867 }
868 (__Field::__field5, __variant) => {
869 _serde::de::VariantAccess::unit_variant(__variant)?;
870 _serde::__private::Ok(TextureUsageType::DISPLACEMENT)
871 }
872 (__Field::__field6, __variant) => {
873 _serde::de::VariantAccess::unit_variant(__variant)?;
874 _serde::__private::Ok(TextureUsageType::SPECULAR)
875 }
876 (__Field::__field7, __variant) => {
877 _serde::de::VariantAccess::unit_variant(__variant)?;
878 _serde::__private::Ok(TextureUsageType::SPECULARANDGLOSS)
879 }
880 (__Field::__field8, __variant) => {
881 _serde::de::VariantAccess::unit_variant(__variant)?;
882 _serde::__private::Ok(TextureUsageType::OPACITY)
883 }
884 (__Field::__field9, __variant) => {
885 _serde::de::VariantAccess::unit_variant(__variant)?;
886 _serde::__private::Ok(TextureUsageType::EMISSIVE)
887 }
888 (__Field::__field10, __variant) => {
889 _serde::de::VariantAccess::unit_variant(__variant)?;
890 _serde::__private::Ok(TextureUsageType::REFRACTION)
891 }
892 (__Field::__field11, __variant) => {
893 _serde::de::VariantAccess::unit_variant(__variant)?;
894 _serde::__private::Ok(TextureUsageType::GLOSS)
895 }
896 (__Field::__field12, __variant) => {
897 _serde::de::VariantAccess::unit_variant(__variant)?;
898 _serde::__private::Ok(TextureUsageType::NOTEXPORTED)
899 }
900 }
901 }
902 }
903 #[doc(hidden)]
904 const VARIANTS: &'static [&'static str] = &[
905 "UNKNOWN",
906 "DIFFUSE",
907 "REFLECTION",
908 "BUMP",
909 "NORMAL",
910 "DISPLACEMENT",
911 "SPECULAR",
912 "SPECULARANDGLOSS",
913 "OPACITY",
914 "EMISSIVE",
915 "REFRACTION",
916 "GLOSS",
917 "NOTEXPORTED",
918 ];
919 _serde::Deserializer::deserialize_enum(
920 __deserializer,
921 "TextureUsageType",
922 VARIANTS,
923 __Visitor {
924 marker: _serde::__private::PhantomData::<TextureUsageType>,
925 lifetime: _serde::__private::PhantomData,
926 },
927 )
928 }
929 }
930};