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