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