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 hkVertexFormat {
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 = "elements"))]
31 #[cfg_attr(feature = "serde", serde(rename = "elements"))]
32 pub m_elements: [hkVertexFormatElement; 32usize],
33 #[cfg_attr(feature = "json_schema", schemars(rename = "numElements"))]
38 #[cfg_attr(feature = "serde", serde(rename = "numElements"))]
39 pub m_numElements: i32,
40}
41const _: () = {
42 use havok_serde as _serde;
43 impl _serde::HavokClass for hkVertexFormat {
44 #[inline]
45 fn name(&self) -> &'static str {
46 "hkVertexFormat"
47 }
48 #[inline]
49 fn signature(&self) -> _serde::__private::Signature {
50 _serde::__private::Signature::new(0xf11e3ff7)
51 }
52 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
53 fn deps_indexes(&self) -> Vec<usize> {
54 let mut v = Vec::new();
55 v.extend(
56 self
57 .m_elements
58 .iter()
59 .flat_map(|class| class.deps_indexes())
60 .collect::<Vec<usize>>(),
61 );
62 v
63 }
64 }
65 impl _serde::Serialize for hkVertexFormat {
66 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
67 where
68 S: _serde::ser::Serializer,
69 {
70 let class_meta = self
71 .__ptr
72 .map(|name| (name, _serde::__private::Signature::new(0xf11e3ff7)));
73 let mut serializer = __serializer
74 .serialize_struct("hkVertexFormat", class_meta, (260u64, 260u64))?;
75 serializer
76 .serialize_fixed_array_field(
77 "elements",
78 self.m_elements.as_slice(),
79 TypeSize::Struct {
80 size_x86: 8u64,
81 size_x86_64: 8u64,
82 },
83 )?;
84 serializer.serialize_field("numElements", &self.m_numElements)?;
85 serializer.end()
86 }
87 }
88};
89#[doc(hidden)]
90#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
91const _: () = {
92 use havok_serde as _serde;
93 #[automatically_derived]
94 impl<'de> _serde::Deserialize<'de> for hkVertexFormat {
95 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
96 where
97 __D: _serde::Deserializer<'de>,
98 {
99 #[allow(non_camel_case_types)]
100 enum __Field {
101 m_elements,
102 m_numElements,
103 __ignore,
104 }
105 struct __FieldVisitor;
106 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
107 type Value = __Field;
108 fn expecting(
109 &self,
110 __formatter: &mut core::fmt::Formatter,
111 ) -> core::fmt::Result {
112 core::fmt::Formatter::write_str(__formatter, "field identifier")
113 }
114 #[allow(clippy::match_single_binding)]
116 #[allow(clippy::reversed_empty_ranges)]
117 #[allow(clippy::single_match)]
118 fn visit_key<__E>(
119 self,
120 __value: &str,
121 ) -> core::result::Result<Self::Value, __E>
122 where
123 __E: _serde::de::Error,
124 {
125 match __value {
126 "elements" => Ok(__Field::m_elements),
127 "numElements" => Ok(__Field::m_numElements),
128 _ => Ok(__Field::__ignore),
129 }
130 }
131 }
132 impl<'de> _serde::Deserialize<'de> for __Field {
133 #[inline]
134 fn deserialize<__D>(
135 __deserializer: __D,
136 ) -> core::result::Result<Self, __D::Error>
137 where
138 __D: _serde::Deserializer<'de>,
139 {
140 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
141 }
142 }
143 struct __hkVertexFormatVisitor<'de> {
144 marker: _serde::__private::PhantomData<hkVertexFormat>,
145 lifetime: _serde::__private::PhantomData<&'de ()>,
146 }
147 #[allow(clippy::match_single_binding)]
148 #[allow(clippy::reversed_empty_ranges)]
149 #[allow(clippy::single_match)]
150 impl<'de> _serde::de::Visitor<'de> for __hkVertexFormatVisitor<'de> {
151 type Value = hkVertexFormat;
152 fn expecting(
153 &self,
154 __formatter: &mut core::fmt::Formatter,
155 ) -> core::fmt::Result {
156 core::fmt::Formatter::write_str(__formatter, "struct hkVertexFormat")
157 }
158 fn visit_struct_for_bytes<__A>(
159 self,
160 mut __map: __A,
161 ) -> _serde::__private::Result<Self::Value, __A::Error>
162 where
163 __A: _serde::de::MapAccess<'de>,
164 {
165 let __ptr = __A::class_ptr(&mut __map);
166 let mut m_elements: _serde::__private::Option<
167 [hkVertexFormatElement; 32usize],
168 > = _serde::__private::None;
169 let mut m_numElements: _serde::__private::Option<i32> = _serde::__private::None;
170 for i in 0..2usize {
171 match i {
172 0usize => {
173 if _serde::__private::Option::is_some(&m_elements) {
174 return _serde::__private::Err(
175 <__A::Error as _serde::de::Error>::duplicate_field(
176 "elements",
177 ),
178 );
179 }
180 m_elements = _serde::__private::Some(
181 match __A::next_value::<
182 [hkVertexFormatElement; 32usize],
183 >(&mut __map) {
184 _serde::__private::Ok(__val) => __val,
185 _serde::__private::Err(__err) => {
186 return _serde::__private::Err(__err);
187 }
188 },
189 );
190 }
191 1usize => {
192 if _serde::__private::Option::is_some(&m_numElements) {
193 return _serde::__private::Err(
194 <__A::Error as _serde::de::Error>::duplicate_field(
195 "numElements",
196 ),
197 );
198 }
199 m_numElements = _serde::__private::Some(
200 match __A::next_value::<i32>(&mut __map) {
201 _serde::__private::Ok(__val) => __val,
202 _serde::__private::Err(__err) => {
203 return _serde::__private::Err(__err);
204 }
205 },
206 );
207 }
208 _ => {}
209 }
210 }
211 let m_elements = match m_elements {
212 _serde::__private::Some(__field) => __field,
213 _serde::__private::None => {
214 return _serde::__private::Err(
215 <__A::Error as _serde::de::Error>::missing_field("elements"),
216 );
217 }
218 };
219 let m_numElements = match m_numElements {
220 _serde::__private::Some(__field) => __field,
221 _serde::__private::None => {
222 return _serde::__private::Err(
223 <__A::Error as _serde::de::Error>::missing_field(
224 "numElements",
225 ),
226 );
227 }
228 };
229 _serde::__private::Ok(hkVertexFormat {
230 __ptr,
231 m_elements,
232 m_numElements,
233 })
234 }
235 #[allow(clippy::manual_unwrap_or_default)]
236 fn visit_struct<__A>(
237 self,
238 mut __map: __A,
239 ) -> _serde::__private::Result<Self::Value, __A::Error>
240 where
241 __A: _serde::de::MapAccess<'de>,
242 {
243 let mut m_elements: _serde::__private::Option<
244 [hkVertexFormatElement; 32usize],
245 > = _serde::__private::None;
246 let mut m_numElements: _serde::__private::Option<i32> = _serde::__private::None;
247 while let _serde::__private::Some(__key) = {
248 __A::next_key::<__Field>(&mut __map)?
249 } {
250 match __key {
251 __Field::m_elements => {
252 #[cfg(
253 any(feature = "strict", feature = "ignore_duplicates")
254 )]
255 if _serde::__private::Option::is_some(&m_elements) {
256 #[cfg(feature = "ignore_duplicates")]
257 {
258 __A::skip_value(&mut __map)?;
259 continue;
260 }
261 #[cfg(feature = "strict")]
262 return _serde::__private::Err(
263 <__A::Error as _serde::de::Error>::duplicate_field(
264 "elements",
265 ),
266 );
267 }
268 m_elements = _serde::__private::Some(
269 match __A::next_value::<
270 [hkVertexFormatElement; 32usize],
271 >(&mut __map) {
272 _serde::__private::Ok(__val) => __val,
273 _serde::__private::Err(__err) => {
274 return _serde::__private::Err(__err);
275 }
276 },
277 );
278 }
279 __Field::m_numElements => {
280 #[cfg(
281 any(feature = "strict", feature = "ignore_duplicates")
282 )]
283 if _serde::__private::Option::is_some(&m_numElements) {
284 #[cfg(feature = "ignore_duplicates")]
285 {
286 __A::skip_value(&mut __map)?;
287 continue;
288 }
289 #[cfg(feature = "strict")]
290 return _serde::__private::Err(
291 <__A::Error as _serde::de::Error>::duplicate_field(
292 "numElements",
293 ),
294 );
295 }
296 m_numElements = _serde::__private::Some(
297 match __A::next_value::<i32>(&mut __map) {
298 _serde::__private::Ok(__val) => __val,
299 _serde::__private::Err(__err) => {
300 return _serde::__private::Err(__err);
301 }
302 },
303 );
304 }
305 _ => __A::skip_value(&mut __map)?,
306 }
307 }
308 let m_elements = match m_elements {
309 _serde::__private::Some(__field) => __field,
310 _serde::__private::None => {
311 #[cfg(feature = "strict")]
312 return _serde::__private::Err(
313 <__A::Error as _serde::de::Error>::missing_field("elements"),
314 );
315 #[cfg(not(feature = "strict"))] Default::default()
316 }
317 };
318 let m_numElements = match m_numElements {
319 _serde::__private::Some(__field) => __field,
320 _serde::__private::None => {
321 #[cfg(feature = "strict")]
322 return _serde::__private::Err(
323 <__A::Error as _serde::de::Error>::missing_field(
324 "numElements",
325 ),
326 );
327 #[cfg(not(feature = "strict"))] Default::default()
328 }
329 };
330 let __ptr = __A::class_ptr(&mut __map);
331 _serde::__private::Ok(hkVertexFormat {
332 __ptr,
333 m_elements,
334 m_numElements,
335 })
336 }
337 }
338 const FIELDS: &[&str] = &["elements", "numElements"];
339 _serde::Deserializer::deserialize_struct(
340 deserializer,
341 "hkVertexFormat",
342 FIELDS,
343 __hkVertexFormatVisitor {
344 marker: _serde::__private::PhantomData::<hkVertexFormat>,
345 lifetime: _serde::__private::PhantomData,
346 },
347 )
348 }
349 }
350};
351#[allow(non_upper_case_globals, non_snake_case)]
354#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
355#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
356#[derive(
357 Debug,
358 Clone,
359 Default,
360 PartialEq,
361 Eq,
362 PartialOrd,
363 Ord,
364 num_derive::ToPrimitive,
365 num_derive::FromPrimitive,
366)]
367pub enum ComponentType {
368 #[default]
369 TYPE_NONE = 0isize,
370 TYPE_INT8 = 1isize,
371 TYPE_UINT8 = 2isize,
372 TYPE_INT16 = 3isize,
373 TYPE_UINT16 = 4isize,
374 TYPE_INT32 = 5isize,
375 TYPE_UINT32 = 6isize,
376 TYPE_UINT8_DWORD = 7isize,
377 TYPE_ARGB32 = 8isize,
378 TYPE_FLOAT16 = 9isize,
379 TYPE_FLOAT32 = 10isize,
380 TYPE_VECTOR4 = 11isize,
381 TYPE_LAST = 12isize,
382}
383#[allow(non_upper_case_globals, non_snake_case)]
386#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
387#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
388#[derive(
389 Debug,
390 Clone,
391 Default,
392 PartialEq,
393 Eq,
394 PartialOrd,
395 Ord,
396 num_derive::ToPrimitive,
397 num_derive::FromPrimitive,
398)]
399pub enum ComponentUsage {
400 #[default]
401 USAGE_NONE = 0isize,
402 USAGE_POSITION = 1isize,
403 USAGE_NORMAL = 2isize,
404 USAGE_COLOR = 3isize,
405 USAGE_TANGENT = 4isize,
406 USAGE_BINORMAL = 5isize,
407 USAGE_BLEND_MATRIX_INDEX = 6isize,
408 USAGE_BLEND_WEIGHTS = 7isize,
409 USAGE_BLEND_WEIGHTS_LAST_IMPLIED = 8isize,
410 USAGE_TEX_COORD = 9isize,
411 USAGE_POINT_SIZE = 10isize,
412 USAGE_USER = 11isize,
413 USAGE_LAST = 12isize,
414}
415#[havok_types_derive::impl_flags_methods]
416bitflags::bitflags! {
417 #[doc = r" Bit flags"] #[doc = r""] #[doc = r" # C++ Info"] #[doc =
418 " - name: `HintFlags`(ctype: `hkFlags<HintFlags, hkUint8>`)"]
419 #[allow(non_upper_case_globals, non_snake_case)] #[cfg_attr(feature = "serde",
420 derive(serde_with::SerializeDisplay, serde_with::DeserializeFromStr))]
421 #[repr(transparent)] #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct
422 HintFlags : u8 { #[doc = "1"] const FLAG_READ = 1u8; #[doc = "2"] const FLAG_WRITE =
423 2u8; #[doc = "4"] const FLAG_DYNAMIC = 4u8; #[doc = "8"] const FLAG_NOT_SHARED = 8u8;
424 }
425}
426#[cfg(feature = "json_schema")]
427const _: () = {
428 use schemars::{SchemaGenerator, Schema, JsonSchema, json_schema};
429 use std::borrow::Cow;
430 impl JsonSchema for HintFlags {
431 fn schema_name() -> Cow<'static, str> {
432 "HintFlags".into()
433 }
434 fn schema_id() -> Cow<'static, str> {
435 concat!(module_path!(), "::", "HintFlags").into()
436 }
437 fn json_schema(_generate: &mut SchemaGenerator) -> Schema {
438 json_schema!(
439 { "description" :
440 "Bitflags field. Specific flags: FLAG_READ: 1, FLAG_WRITE: 2, FLAG_DYNAMIC: 4, FLAG_NOT_SHARED: 8. Additional unspecified bits may be set.(e.g.: BIT_FLAG|BIT_FLAG2|4)",
441 "type" : "string", }
442 )
443 }
444 }
445};
446const _: () = {
447 use havok_serde as __serde;
448 impl __serde::Serialize for ComponentType {
449 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
450 where
451 S: __serde::ser::Serializer,
452 {
453 let mut __serializer = __serializer.serialize_enum_flags()?;
454 match self {
455 Self::TYPE_NONE => __serializer.serialize_field("TYPE_NONE", &0u64),
456 Self::TYPE_INT8 => __serializer.serialize_field("TYPE_INT8", &1u64),
457 Self::TYPE_UINT8 => __serializer.serialize_field("TYPE_UINT8", &2u64),
458 Self::TYPE_INT16 => __serializer.serialize_field("TYPE_INT16", &3u64),
459 Self::TYPE_UINT16 => __serializer.serialize_field("TYPE_UINT16", &4u64),
460 Self::TYPE_INT32 => __serializer.serialize_field("TYPE_INT32", &5u64),
461 Self::TYPE_UINT32 => __serializer.serialize_field("TYPE_UINT32", &6u64),
462 Self::TYPE_UINT8_DWORD => {
463 __serializer.serialize_field("TYPE_UINT8_DWORD", &7u64)
464 }
465 Self::TYPE_ARGB32 => __serializer.serialize_field("TYPE_ARGB32", &8u64),
466 Self::TYPE_FLOAT16 => __serializer.serialize_field("TYPE_FLOAT16", &9u64),
467 Self::TYPE_FLOAT32 => {
468 __serializer.serialize_field("TYPE_FLOAT32", &10u64)
469 }
470 Self::TYPE_VECTOR4 => {
471 __serializer.serialize_field("TYPE_VECTOR4", &11u64)
472 }
473 Self::TYPE_LAST => __serializer.serialize_field("TYPE_LAST", &12u64),
474 }?;
475 use num_traits::ToPrimitive as _;
476 let num = self
477 .to_u8()
478 .ok_or(S::Error::custom("Failed enum ComponentType to_u8"))?;
479 __serializer.serialize_bits(&num)?;
480 __serializer.end()
481 }
482 }
483};
484const _: () = {
485 use havok_serde as __serde;
486 impl __serde::Serialize for ComponentUsage {
487 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
488 where
489 S: __serde::ser::Serializer,
490 {
491 let mut __serializer = __serializer.serialize_enum_flags()?;
492 match self {
493 Self::USAGE_NONE => __serializer.serialize_field("USAGE_NONE", &0u64),
494 Self::USAGE_POSITION => {
495 __serializer.serialize_field("USAGE_POSITION", &1u64)
496 }
497 Self::USAGE_NORMAL => __serializer.serialize_field("USAGE_NORMAL", &2u64),
498 Self::USAGE_COLOR => __serializer.serialize_field("USAGE_COLOR", &3u64),
499 Self::USAGE_TANGENT => {
500 __serializer.serialize_field("USAGE_TANGENT", &4u64)
501 }
502 Self::USAGE_BINORMAL => {
503 __serializer.serialize_field("USAGE_BINORMAL", &5u64)
504 }
505 Self::USAGE_BLEND_MATRIX_INDEX => {
506 __serializer.serialize_field("USAGE_BLEND_MATRIX_INDEX", &6u64)
507 }
508 Self::USAGE_BLEND_WEIGHTS => {
509 __serializer.serialize_field("USAGE_BLEND_WEIGHTS", &7u64)
510 }
511 Self::USAGE_BLEND_WEIGHTS_LAST_IMPLIED => {
512 __serializer
513 .serialize_field("USAGE_BLEND_WEIGHTS_LAST_IMPLIED", &8u64)
514 }
515 Self::USAGE_TEX_COORD => {
516 __serializer.serialize_field("USAGE_TEX_COORD", &9u64)
517 }
518 Self::USAGE_POINT_SIZE => {
519 __serializer.serialize_field("USAGE_POINT_SIZE", &10u64)
520 }
521 Self::USAGE_USER => __serializer.serialize_field("USAGE_USER", &11u64),
522 Self::USAGE_LAST => __serializer.serialize_field("USAGE_LAST", &12u64),
523 }?;
524 use num_traits::ToPrimitive as _;
525 let num = self
526 .to_u8()
527 .ok_or(S::Error::custom("Failed enum ComponentUsage to_u8"))?;
528 __serializer.serialize_bits(&num)?;
529 __serializer.end()
530 }
531 }
532};
533const _: () = {
534 use havok_serde as __serde;
535 impl __serde::Serialize for HintFlags {
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 if self.is_empty() {
542 __serializer.serialize_bits(&self.bits())?;
543 __serializer.serialize_empty_bit()?;
544 return __serializer.end();
545 }
546 for flag in self.iter() {
547 match flag {
548 Self::FLAG_READ => {
549 __serializer.serialize_field("FLAG_READ", &Self::FLAG_READ)
550 }
551 Self::FLAG_WRITE => {
552 __serializer.serialize_field("FLAG_WRITE", &Self::FLAG_WRITE)
553 }
554 Self::FLAG_DYNAMIC => {
555 __serializer.serialize_field("FLAG_DYNAMIC", &Self::FLAG_DYNAMIC)
556 }
557 Self::FLAG_NOT_SHARED => {
558 __serializer
559 .serialize_field("FLAG_NOT_SHARED", &Self::FLAG_NOT_SHARED)
560 }
561 remain => {
562 __serializer
563 .serialize_field(&remain.bits().to_string(), &remain.bits())
564 }
565 }?;
566 }
567 __serializer.serialize_bits(&self.bits())?;
568 __serializer.end()
569 }
570 }
571};
572#[doc(hidden)]
573#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
574const _: () = {
575 #[allow(unused_extern_crates, clippy::useless_attribute)]
576 extern crate havok_serde as _serde;
577 #[automatically_derived]
578 impl<'de> _serde::Deserialize<'de> for ComponentType {
579 fn deserialize<__D>(
580 __deserializer: __D,
581 ) -> _serde::__private::Result<Self, __D::Error>
582 where
583 __D: _serde::Deserializer<'de>,
584 {
585 #[allow(non_camel_case_types)]
586 #[doc(hidden)]
587 enum __Field {
588 __field0,
589 __field1,
590 __field2,
591 __field3,
592 __field4,
593 __field5,
594 __field6,
595 __field7,
596 __field8,
597 __field9,
598 __field10,
599 __field11,
600 __field12,
601 }
602 #[doc(hidden)]
603 struct __FieldVisitor;
604 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
605 type Value = __Field;
606 fn expecting(
607 &self,
608 __formatter: &mut _serde::__private::Formatter,
609 ) -> _serde::__private::fmt::Result {
610 _serde::__private::Formatter::write_str(
611 __formatter,
612 "variant identifier",
613 )
614 }
615 fn visit_uint8<__E>(
616 self,
617 __value: u8,
618 ) -> _serde::__private::Result<Self::Value, __E>
619 where
620 __E: _serde::de::Error,
621 {
622 match __value {
623 0u8 => _serde::__private::Ok(__Field::__field0),
624 1u8 => _serde::__private::Ok(__Field::__field1),
625 2u8 => _serde::__private::Ok(__Field::__field2),
626 3u8 => _serde::__private::Ok(__Field::__field3),
627 4u8 => _serde::__private::Ok(__Field::__field4),
628 5u8 => _serde::__private::Ok(__Field::__field5),
629 6u8 => _serde::__private::Ok(__Field::__field6),
630 7u8 => _serde::__private::Ok(__Field::__field7),
631 8u8 => _serde::__private::Ok(__Field::__field8),
632 9u8 => _serde::__private::Ok(__Field::__field9),
633 10u8 => _serde::__private::Ok(__Field::__field10),
634 11u8 => _serde::__private::Ok(__Field::__field11),
635 12u8 => _serde::__private::Ok(__Field::__field12),
636 _ => {
637 _serde::__private::Err(
638 _serde::de::Error::invalid_value(
639 _serde::de::Unexpected::Uint8(__value),
640 &"value(u8) of variant is one of 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12",
641 ),
642 )
643 }
644 }
645 }
646 fn visit_stringptr<__E>(
647 self,
648 __value: StringPtr<'de>,
649 ) -> _serde::__private::Result<Self::Value, __E>
650 where
651 __E: _serde::de::Error,
652 {
653 if let Some(__value) = __value.into_inner() {
654 match __value.as_ref() {
655 v if v == "0" || v.eq_ignore_ascii_case("TYPE_NONE") => {
656 _serde::__private::Ok(__Field::__field0)
657 }
658 v if v == "1" || v.eq_ignore_ascii_case("TYPE_INT8") => {
659 _serde::__private::Ok(__Field::__field1)
660 }
661 v if v == "2" || v.eq_ignore_ascii_case("TYPE_UINT8") => {
662 _serde::__private::Ok(__Field::__field2)
663 }
664 v if v == "3" || v.eq_ignore_ascii_case("TYPE_INT16") => {
665 _serde::__private::Ok(__Field::__field3)
666 }
667 v if v == "4" || v.eq_ignore_ascii_case("TYPE_UINT16") => {
668 _serde::__private::Ok(__Field::__field4)
669 }
670 v if v == "5" || v.eq_ignore_ascii_case("TYPE_INT32") => {
671 _serde::__private::Ok(__Field::__field5)
672 }
673 v if v == "6" || v.eq_ignore_ascii_case("TYPE_UINT32") => {
674 _serde::__private::Ok(__Field::__field6)
675 }
676 v if v == "7"
677 || v.eq_ignore_ascii_case("TYPE_UINT8_DWORD") => {
678 _serde::__private::Ok(__Field::__field7)
679 }
680 v if v == "8" || v.eq_ignore_ascii_case("TYPE_ARGB32") => {
681 _serde::__private::Ok(__Field::__field8)
682 }
683 v if v == "9" || v.eq_ignore_ascii_case("TYPE_FLOAT16") => {
684 _serde::__private::Ok(__Field::__field9)
685 }
686 v if v == "10" || v.eq_ignore_ascii_case("TYPE_FLOAT32") => {
687 _serde::__private::Ok(__Field::__field10)
688 }
689 v if v == "11" || v.eq_ignore_ascii_case("TYPE_VECTOR4") => {
690 _serde::__private::Ok(__Field::__field11)
691 }
692 v if v == "12" || v.eq_ignore_ascii_case("TYPE_LAST") => {
693 _serde::__private::Ok(__Field::__field12)
694 }
695 _ => {
696 _serde::__private::Err(
697 _serde::de::Error::unknown_variant(&__value, VARIANTS),
698 )
699 }
700 }
701 } else {
702 _serde::__private::Err(
703 _serde::de::Error::unknown_variant("None", VARIANTS),
704 )
705 }
706 }
707 }
708 impl<'de> _serde::Deserialize<'de> for __Field {
709 #[inline]
710 fn deserialize<__D>(
711 __deserializer: __D,
712 ) -> _serde::__private::Result<Self, __D::Error>
713 where
714 __D: _serde::Deserializer<'de>,
715 {
716 _serde::Deserializer::deserialize_identifier(
717 __deserializer,
718 _serde::de::ReadEnumSize::Uint8,
719 __FieldVisitor,
720 )
721 }
722 }
723 #[doc(hidden)]
724 struct __Visitor<'de> {
725 marker: _serde::__private::PhantomData<ComponentType>,
726 lifetime: _serde::__private::PhantomData<&'de ()>,
727 }
728 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
729 type Value = ComponentType;
730 fn expecting(
731 &self,
732 __formatter: &mut _serde::__private::Formatter,
733 ) -> _serde::__private::fmt::Result {
734 _serde::__private::Formatter::write_str(
735 __formatter,
736 "enum ComponentType",
737 )
738 }
739 fn visit_enum<__A>(
740 self,
741 __data: __A,
742 ) -> _serde::__private::Result<Self::Value, __A::Error>
743 where
744 __A: _serde::de::EnumAccess<'de>,
745 {
746 match _serde::de::EnumAccess::variant(__data)? {
747 (__Field::__field0, __variant) => {
748 _serde::de::VariantAccess::unit_variant(__variant)?;
749 _serde::__private::Ok(ComponentType::TYPE_NONE)
750 }
751 (__Field::__field1, __variant) => {
752 _serde::de::VariantAccess::unit_variant(__variant)?;
753 _serde::__private::Ok(ComponentType::TYPE_INT8)
754 }
755 (__Field::__field2, __variant) => {
756 _serde::de::VariantAccess::unit_variant(__variant)?;
757 _serde::__private::Ok(ComponentType::TYPE_UINT8)
758 }
759 (__Field::__field3, __variant) => {
760 _serde::de::VariantAccess::unit_variant(__variant)?;
761 _serde::__private::Ok(ComponentType::TYPE_INT16)
762 }
763 (__Field::__field4, __variant) => {
764 _serde::de::VariantAccess::unit_variant(__variant)?;
765 _serde::__private::Ok(ComponentType::TYPE_UINT16)
766 }
767 (__Field::__field5, __variant) => {
768 _serde::de::VariantAccess::unit_variant(__variant)?;
769 _serde::__private::Ok(ComponentType::TYPE_INT32)
770 }
771 (__Field::__field6, __variant) => {
772 _serde::de::VariantAccess::unit_variant(__variant)?;
773 _serde::__private::Ok(ComponentType::TYPE_UINT32)
774 }
775 (__Field::__field7, __variant) => {
776 _serde::de::VariantAccess::unit_variant(__variant)?;
777 _serde::__private::Ok(ComponentType::TYPE_UINT8_DWORD)
778 }
779 (__Field::__field8, __variant) => {
780 _serde::de::VariantAccess::unit_variant(__variant)?;
781 _serde::__private::Ok(ComponentType::TYPE_ARGB32)
782 }
783 (__Field::__field9, __variant) => {
784 _serde::de::VariantAccess::unit_variant(__variant)?;
785 _serde::__private::Ok(ComponentType::TYPE_FLOAT16)
786 }
787 (__Field::__field10, __variant) => {
788 _serde::de::VariantAccess::unit_variant(__variant)?;
789 _serde::__private::Ok(ComponentType::TYPE_FLOAT32)
790 }
791 (__Field::__field11, __variant) => {
792 _serde::de::VariantAccess::unit_variant(__variant)?;
793 _serde::__private::Ok(ComponentType::TYPE_VECTOR4)
794 }
795 (__Field::__field12, __variant) => {
796 _serde::de::VariantAccess::unit_variant(__variant)?;
797 _serde::__private::Ok(ComponentType::TYPE_LAST)
798 }
799 }
800 }
801 }
802 #[doc(hidden)]
803 const VARIANTS: &'static [&'static str] = &[
804 "TYPE_NONE",
805 "TYPE_INT8",
806 "TYPE_UINT8",
807 "TYPE_INT16",
808 "TYPE_UINT16",
809 "TYPE_INT32",
810 "TYPE_UINT32",
811 "TYPE_UINT8_DWORD",
812 "TYPE_ARGB32",
813 "TYPE_FLOAT16",
814 "TYPE_FLOAT32",
815 "TYPE_VECTOR4",
816 "TYPE_LAST",
817 ];
818 _serde::Deserializer::deserialize_enum(
819 __deserializer,
820 "ComponentType",
821 VARIANTS,
822 __Visitor {
823 marker: _serde::__private::PhantomData::<ComponentType>,
824 lifetime: _serde::__private::PhantomData,
825 },
826 )
827 }
828 }
829};
830#[doc(hidden)]
831#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
832const _: () = {
833 #[allow(unused_extern_crates, clippy::useless_attribute)]
834 extern crate havok_serde as _serde;
835 #[automatically_derived]
836 impl<'de> _serde::Deserialize<'de> for ComponentUsage {
837 fn deserialize<__D>(
838 __deserializer: __D,
839 ) -> _serde::__private::Result<Self, __D::Error>
840 where
841 __D: _serde::Deserializer<'de>,
842 {
843 #[allow(non_camel_case_types)]
844 #[doc(hidden)]
845 enum __Field {
846 __field0,
847 __field1,
848 __field2,
849 __field3,
850 __field4,
851 __field5,
852 __field6,
853 __field7,
854 __field8,
855 __field9,
856 __field10,
857 __field11,
858 __field12,
859 }
860 #[doc(hidden)]
861 struct __FieldVisitor;
862 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
863 type Value = __Field;
864 fn expecting(
865 &self,
866 __formatter: &mut _serde::__private::Formatter,
867 ) -> _serde::__private::fmt::Result {
868 _serde::__private::Formatter::write_str(
869 __formatter,
870 "variant identifier",
871 )
872 }
873 fn visit_uint8<__E>(
874 self,
875 __value: u8,
876 ) -> _serde::__private::Result<Self::Value, __E>
877 where
878 __E: _serde::de::Error,
879 {
880 match __value {
881 0u8 => _serde::__private::Ok(__Field::__field0),
882 1u8 => _serde::__private::Ok(__Field::__field1),
883 2u8 => _serde::__private::Ok(__Field::__field2),
884 3u8 => _serde::__private::Ok(__Field::__field3),
885 4u8 => _serde::__private::Ok(__Field::__field4),
886 5u8 => _serde::__private::Ok(__Field::__field5),
887 6u8 => _serde::__private::Ok(__Field::__field6),
888 7u8 => _serde::__private::Ok(__Field::__field7),
889 8u8 => _serde::__private::Ok(__Field::__field8),
890 9u8 => _serde::__private::Ok(__Field::__field9),
891 10u8 => _serde::__private::Ok(__Field::__field10),
892 11u8 => _serde::__private::Ok(__Field::__field11),
893 12u8 => _serde::__private::Ok(__Field::__field12),
894 _ => {
895 _serde::__private::Err(
896 _serde::de::Error::invalid_value(
897 _serde::de::Unexpected::Uint8(__value),
898 &"value(u8) of variant is one of 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12",
899 ),
900 )
901 }
902 }
903 }
904 fn visit_stringptr<__E>(
905 self,
906 __value: StringPtr<'de>,
907 ) -> _serde::__private::Result<Self::Value, __E>
908 where
909 __E: _serde::de::Error,
910 {
911 if let Some(__value) = __value.into_inner() {
912 match __value.as_ref() {
913 v if v == "0" || v.eq_ignore_ascii_case("USAGE_NONE") => {
914 _serde::__private::Ok(__Field::__field0)
915 }
916 v if v == "1" || v.eq_ignore_ascii_case("USAGE_POSITION") => {
917 _serde::__private::Ok(__Field::__field1)
918 }
919 v if v == "2" || v.eq_ignore_ascii_case("USAGE_NORMAL") => {
920 _serde::__private::Ok(__Field::__field2)
921 }
922 v if v == "3" || v.eq_ignore_ascii_case("USAGE_COLOR") => {
923 _serde::__private::Ok(__Field::__field3)
924 }
925 v if v == "4" || v.eq_ignore_ascii_case("USAGE_TANGENT") => {
926 _serde::__private::Ok(__Field::__field4)
927 }
928 v if v == "5" || v.eq_ignore_ascii_case("USAGE_BINORMAL") => {
929 _serde::__private::Ok(__Field::__field5)
930 }
931 v if v == "6"
932 || v.eq_ignore_ascii_case("USAGE_BLEND_MATRIX_INDEX") => {
933 _serde::__private::Ok(__Field::__field6)
934 }
935 v if v == "7"
936 || v.eq_ignore_ascii_case("USAGE_BLEND_WEIGHTS") => {
937 _serde::__private::Ok(__Field::__field7)
938 }
939 v if v == "8"
940 || v
941 .eq_ignore_ascii_case(
942 "USAGE_BLEND_WEIGHTS_LAST_IMPLIED",
943 ) => _serde::__private::Ok(__Field::__field8),
944 v if v == "9"
945 || v.eq_ignore_ascii_case("USAGE_TEX_COORD") => {
946 _serde::__private::Ok(__Field::__field9)
947 }
948 v if v == "10"
949 || v.eq_ignore_ascii_case("USAGE_POINT_SIZE") => {
950 _serde::__private::Ok(__Field::__field10)
951 }
952 v if v == "11" || v.eq_ignore_ascii_case("USAGE_USER") => {
953 _serde::__private::Ok(__Field::__field11)
954 }
955 v if v == "12" || v.eq_ignore_ascii_case("USAGE_LAST") => {
956 _serde::__private::Ok(__Field::__field12)
957 }
958 _ => {
959 _serde::__private::Err(
960 _serde::de::Error::unknown_variant(&__value, VARIANTS),
961 )
962 }
963 }
964 } else {
965 _serde::__private::Err(
966 _serde::de::Error::unknown_variant("None", VARIANTS),
967 )
968 }
969 }
970 }
971 impl<'de> _serde::Deserialize<'de> for __Field {
972 #[inline]
973 fn deserialize<__D>(
974 __deserializer: __D,
975 ) -> _serde::__private::Result<Self, __D::Error>
976 where
977 __D: _serde::Deserializer<'de>,
978 {
979 _serde::Deserializer::deserialize_identifier(
980 __deserializer,
981 _serde::de::ReadEnumSize::Uint8,
982 __FieldVisitor,
983 )
984 }
985 }
986 #[doc(hidden)]
987 struct __Visitor<'de> {
988 marker: _serde::__private::PhantomData<ComponentUsage>,
989 lifetime: _serde::__private::PhantomData<&'de ()>,
990 }
991 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
992 type Value = ComponentUsage;
993 fn expecting(
994 &self,
995 __formatter: &mut _serde::__private::Formatter,
996 ) -> _serde::__private::fmt::Result {
997 _serde::__private::Formatter::write_str(
998 __formatter,
999 "enum ComponentUsage",
1000 )
1001 }
1002 fn visit_enum<__A>(
1003 self,
1004 __data: __A,
1005 ) -> _serde::__private::Result<Self::Value, __A::Error>
1006 where
1007 __A: _serde::de::EnumAccess<'de>,
1008 {
1009 match _serde::de::EnumAccess::variant(__data)? {
1010 (__Field::__field0, __variant) => {
1011 _serde::de::VariantAccess::unit_variant(__variant)?;
1012 _serde::__private::Ok(ComponentUsage::USAGE_NONE)
1013 }
1014 (__Field::__field1, __variant) => {
1015 _serde::de::VariantAccess::unit_variant(__variant)?;
1016 _serde::__private::Ok(ComponentUsage::USAGE_POSITION)
1017 }
1018 (__Field::__field2, __variant) => {
1019 _serde::de::VariantAccess::unit_variant(__variant)?;
1020 _serde::__private::Ok(ComponentUsage::USAGE_NORMAL)
1021 }
1022 (__Field::__field3, __variant) => {
1023 _serde::de::VariantAccess::unit_variant(__variant)?;
1024 _serde::__private::Ok(ComponentUsage::USAGE_COLOR)
1025 }
1026 (__Field::__field4, __variant) => {
1027 _serde::de::VariantAccess::unit_variant(__variant)?;
1028 _serde::__private::Ok(ComponentUsage::USAGE_TANGENT)
1029 }
1030 (__Field::__field5, __variant) => {
1031 _serde::de::VariantAccess::unit_variant(__variant)?;
1032 _serde::__private::Ok(ComponentUsage::USAGE_BINORMAL)
1033 }
1034 (__Field::__field6, __variant) => {
1035 _serde::de::VariantAccess::unit_variant(__variant)?;
1036 _serde::__private::Ok(
1037 ComponentUsage::USAGE_BLEND_MATRIX_INDEX,
1038 )
1039 }
1040 (__Field::__field7, __variant) => {
1041 _serde::de::VariantAccess::unit_variant(__variant)?;
1042 _serde::__private::Ok(ComponentUsage::USAGE_BLEND_WEIGHTS)
1043 }
1044 (__Field::__field8, __variant) => {
1045 _serde::de::VariantAccess::unit_variant(__variant)?;
1046 _serde::__private::Ok(
1047 ComponentUsage::USAGE_BLEND_WEIGHTS_LAST_IMPLIED,
1048 )
1049 }
1050 (__Field::__field9, __variant) => {
1051 _serde::de::VariantAccess::unit_variant(__variant)?;
1052 _serde::__private::Ok(ComponentUsage::USAGE_TEX_COORD)
1053 }
1054 (__Field::__field10, __variant) => {
1055 _serde::de::VariantAccess::unit_variant(__variant)?;
1056 _serde::__private::Ok(ComponentUsage::USAGE_POINT_SIZE)
1057 }
1058 (__Field::__field11, __variant) => {
1059 _serde::de::VariantAccess::unit_variant(__variant)?;
1060 _serde::__private::Ok(ComponentUsage::USAGE_USER)
1061 }
1062 (__Field::__field12, __variant) => {
1063 _serde::de::VariantAccess::unit_variant(__variant)?;
1064 _serde::__private::Ok(ComponentUsage::USAGE_LAST)
1065 }
1066 }
1067 }
1068 }
1069 #[doc(hidden)]
1070 const VARIANTS: &'static [&'static str] = &[
1071 "USAGE_NONE",
1072 "USAGE_POSITION",
1073 "USAGE_NORMAL",
1074 "USAGE_COLOR",
1075 "USAGE_TANGENT",
1076 "USAGE_BINORMAL",
1077 "USAGE_BLEND_MATRIX_INDEX",
1078 "USAGE_BLEND_WEIGHTS",
1079 "USAGE_BLEND_WEIGHTS_LAST_IMPLIED",
1080 "USAGE_TEX_COORD",
1081 "USAGE_POINT_SIZE",
1082 "USAGE_USER",
1083 "USAGE_LAST",
1084 ];
1085 _serde::Deserializer::deserialize_enum(
1086 __deserializer,
1087 "ComponentUsage",
1088 VARIANTS,
1089 __Visitor {
1090 marker: _serde::__private::PhantomData::<ComponentUsage>,
1091 lifetime: _serde::__private::PhantomData,
1092 },
1093 )
1094 }
1095 }
1096};
1097#[doc(hidden)]
1098#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1099const _: () = {
1100 #[allow(unused_extern_crates, clippy::useless_attribute)]
1101 extern crate havok_serde as _serde;
1102 #[automatically_derived]
1103 impl<'de> _serde::Deserialize<'de> for HintFlags {
1104 fn deserialize<__D>(
1105 __deserializer: __D,
1106 ) -> _serde::__private::Result<Self, __D::Error>
1107 where
1108 __D: _serde::Deserializer<'de>,
1109 {
1110 #[doc(hidden)]
1111 struct __Visitor<'de> {
1112 marker: _serde::__private::PhantomData<HintFlags>,
1113 lifetime: _serde::__private::PhantomData<&'de ()>,
1114 }
1115 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1116 type Value = HintFlags;
1117 fn expecting(
1118 &self,
1119 __formatter: &mut _serde::__private::Formatter,
1120 ) -> _serde::__private::fmt::Result {
1121 _serde::__private::Formatter::write_str(
1122 __formatter,
1123 "struct HintFlags(flags)",
1124 )
1125 }
1126 #[inline]
1127 fn visit_uint8<__E>(
1128 self,
1129 __value: u8,
1130 ) -> _serde::__private::Result<Self::Value, __E>
1131 where
1132 __E: _serde::de::Error,
1133 {
1134 Ok(HintFlags::from_bits_retain(__value as _))
1135 }
1136 fn visit_stringptr<__E>(
1137 self,
1138 __value: StringPtr<'de>,
1139 ) -> _serde::__private::Result<Self::Value, __E>
1140 where
1141 __E: _serde::de::Error,
1142 {
1143 match <HintFlags as core::str::FromStr>::from_str(
1144 __value.into_inner().unwrap().as_ref(),
1145 ) {
1146 Ok(flags) => Ok(flags),
1147 Err(err) => Err(_serde::de::Error::custom(err)),
1148 }
1149 }
1150 }
1151 _serde::Deserializer::deserialize_flags(
1152 __deserializer,
1153 _serde::de::ReadEnumSize::Uint8,
1154 __Visitor {
1155 marker: _serde::__private::PhantomData::<HintFlags>,
1156 lifetime: _serde::__private::PhantomData,
1157 },
1158 )
1159 }
1160 }
1161};