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 hkxMaterial<'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 #[cfg_attr(feature = "serde", serde(borrow))]
30 pub parent: hkxAttributeHolder<'a>,
31 #[cfg_attr(feature = "serde", serde(borrow))]
36 #[cfg_attr(feature = "json_schema", schemars(rename = "name"))]
37 #[cfg_attr(feature = "serde", serde(rename = "name"))]
38 pub m_name: StringPtr<'a>,
39 #[cfg_attr(feature = "json_schema", schemars(rename = "stages"))]
44 #[cfg_attr(feature = "serde", serde(rename = "stages"))]
45 pub m_stages: Vec<hkxMaterialTextureStage>,
46 #[cfg_attr(feature = "json_schema", schemars(rename = "diffuseColor"))]
51 #[cfg_attr(feature = "serde", serde(rename = "diffuseColor"))]
52 pub m_diffuseColor: Vector4,
53 #[cfg_attr(feature = "json_schema", schemars(rename = "ambientColor"))]
58 #[cfg_attr(feature = "serde", serde(rename = "ambientColor"))]
59 pub m_ambientColor: Vector4,
60 #[cfg_attr(feature = "json_schema", schemars(rename = "specularColor"))]
65 #[cfg_attr(feature = "serde", serde(rename = "specularColor"))]
66 pub m_specularColor: Vector4,
67 #[cfg_attr(feature = "json_schema", schemars(rename = "emissiveColor"))]
72 #[cfg_attr(feature = "serde", serde(rename = "emissiveColor"))]
73 pub m_emissiveColor: Vector4,
74 #[cfg_attr(feature = "json_schema", schemars(rename = "subMaterials"))]
79 #[cfg_attr(feature = "serde", serde(rename = "subMaterials"))]
80 pub m_subMaterials: Vec<Pointer>,
81 #[cfg_attr(feature = "json_schema", schemars(rename = "extraData"))]
86 #[cfg_attr(feature = "serde", serde(rename = "extraData"))]
87 pub m_extraData: Pointer,
88 #[cfg_attr(feature = "json_schema", schemars(rename = "properties"))]
93 #[cfg_attr(feature = "serde", serde(rename = "properties"))]
94 pub m_properties: Vec<hkxMaterialProperty>,
95}
96const _: () = {
97 use havok_serde as _serde;
98 impl<'a> _serde::HavokClass for hkxMaterial<'a> {
99 #[inline]
100 fn name(&self) -> &'static str {
101 "hkxMaterial"
102 }
103 #[inline]
104 fn signature(&self) -> _serde::__private::Signature {
105 _serde::__private::Signature::new(0x2954537a)
106 }
107 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
108 fn deps_indexes(&self) -> Vec<usize> {
109 let mut v = Vec::new();
110 v.extend(
111 self
112 .parent
113 .m_attributeGroups
114 .iter()
115 .flat_map(|class| class.deps_indexes())
116 .collect::<Vec<usize>>(),
117 );
118 v.extend(
119 self
120 .m_stages
121 .iter()
122 .flat_map(|class| class.deps_indexes())
123 .collect::<Vec<usize>>(),
124 );
125 v.extend(self.m_subMaterials.iter().map(|ptr| ptr.get()));
126 v.push(self.m_extraData.get());
127 v.extend(
128 self
129 .m_properties
130 .iter()
131 .flat_map(|class| class.deps_indexes())
132 .collect::<Vec<usize>>(),
133 );
134 v
135 }
136 }
137 impl<'a> _serde::Serialize for hkxMaterial<'a> {
138 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
139 where
140 S: _serde::ser::Serializer,
141 {
142 let class_meta = self
143 .__ptr
144 .map(|name| (name, _serde::__private::Signature::new(0x2954537a)));
145 let mut serializer = __serializer
146 .serialize_struct("hkxMaterial", class_meta, (144u64, 176u64))?;
147 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
148 serializer
149 .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
150 serializer
151 .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
152 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
153 serializer
154 .serialize_array_field(
155 "attributeGroups",
156 &self.parent.m_attributeGroups,
157 TypeSize::Struct {
158 size_x86: 16u64,
159 size_x86_64: 24u64,
160 },
161 )?;
162 serializer.serialize_field("name", &self.m_name)?;
163 serializer
164 .serialize_array_field(
165 "stages",
166 &self.m_stages,
167 TypeSize::Struct {
168 size_x86: 12u64,
169 size_x86_64: 16u64,
170 },
171 )?;
172 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 8usize].as_slice())?;
173 serializer.serialize_field("diffuseColor", &self.m_diffuseColor)?;
174 serializer.serialize_field("ambientColor", &self.m_ambientColor)?;
175 serializer.serialize_field("specularColor", &self.m_specularColor)?;
176 serializer.serialize_field("emissiveColor", &self.m_emissiveColor)?;
177 serializer
178 .serialize_array_field(
179 "subMaterials",
180 &self.m_subMaterials,
181 TypeSize::NonPtr,
182 )?;
183 serializer.serialize_field("extraData", &self.m_extraData)?;
184 serializer
185 .serialize_array_field(
186 "properties",
187 &self.m_properties,
188 TypeSize::Struct {
189 size_x86: 8u64,
190 size_x86_64: 8u64,
191 },
192 )?;
193 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
194 serializer.end()
195 }
196 }
197};
198#[doc(hidden)]
199#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
200const _: () = {
201 use havok_serde as _serde;
202 #[automatically_derived]
203 impl<'de> _serde::Deserialize<'de> for hkxMaterial<'de> {
204 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
205 where
206 __D: _serde::Deserializer<'de>,
207 {
208 #[allow(non_camel_case_types)]
209 enum __Field {
210 m_attributeGroups,
211 m_name,
212 m_stages,
213 m_diffuseColor,
214 m_ambientColor,
215 m_specularColor,
216 m_emissiveColor,
217 m_subMaterials,
218 m_extraData,
219 m_properties,
220 __ignore,
221 }
222 struct __FieldVisitor;
223 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
224 type Value = __Field;
225 fn expecting(
226 &self,
227 __formatter: &mut core::fmt::Formatter,
228 ) -> core::fmt::Result {
229 core::fmt::Formatter::write_str(__formatter, "field identifier")
230 }
231 #[allow(clippy::match_single_binding)]
233 #[allow(clippy::reversed_empty_ranges)]
234 #[allow(clippy::single_match)]
235 fn visit_key<__E>(
236 self,
237 __value: &str,
238 ) -> core::result::Result<Self::Value, __E>
239 where
240 __E: _serde::de::Error,
241 {
242 match __value {
243 "attributeGroups" => Ok(__Field::m_attributeGroups),
244 "name" => Ok(__Field::m_name),
245 "stages" => Ok(__Field::m_stages),
246 "diffuseColor" => Ok(__Field::m_diffuseColor),
247 "ambientColor" => Ok(__Field::m_ambientColor),
248 "specularColor" => Ok(__Field::m_specularColor),
249 "emissiveColor" => Ok(__Field::m_emissiveColor),
250 "subMaterials" => Ok(__Field::m_subMaterials),
251 "extraData" => Ok(__Field::m_extraData),
252 "properties" => Ok(__Field::m_properties),
253 _ => Ok(__Field::__ignore),
254 }
255 }
256 }
257 impl<'de> _serde::Deserialize<'de> for __Field {
258 #[inline]
259 fn deserialize<__D>(
260 __deserializer: __D,
261 ) -> core::result::Result<Self, __D::Error>
262 where
263 __D: _serde::Deserializer<'de>,
264 {
265 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
266 }
267 }
268 struct __hkxMaterialVisitor<'de> {
269 marker: _serde::__private::PhantomData<hkxMaterial<'de>>,
270 lifetime: _serde::__private::PhantomData<&'de ()>,
271 }
272 #[allow(clippy::match_single_binding)]
273 #[allow(clippy::reversed_empty_ranges)]
274 #[allow(clippy::single_match)]
275 impl<'de> _serde::de::Visitor<'de> for __hkxMaterialVisitor<'de> {
276 type Value = hkxMaterial<'de>;
277 fn expecting(
278 &self,
279 __formatter: &mut core::fmt::Formatter,
280 ) -> core::fmt::Result {
281 core::fmt::Formatter::write_str(__formatter, "struct hkxMaterial")
282 }
283 fn visit_struct_for_bytes<__A>(
284 self,
285 mut __map: __A,
286 ) -> _serde::__private::Result<Self::Value, __A::Error>
287 where
288 __A: _serde::de::MapAccess<'de>,
289 {
290 let __ptr = __A::class_ptr(&mut __map);
291 let parent = __A::parent_value(&mut __map)?;
292 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
293 let mut m_stages: _serde::__private::Option<
294 Vec<hkxMaterialTextureStage>,
295 > = _serde::__private::None;
296 let mut m_diffuseColor: _serde::__private::Option<Vector4> = _serde::__private::None;
297 let mut m_ambientColor: _serde::__private::Option<Vector4> = _serde::__private::None;
298 let mut m_specularColor: _serde::__private::Option<Vector4> = _serde::__private::None;
299 let mut m_emissiveColor: _serde::__private::Option<Vector4> = _serde::__private::None;
300 let mut m_subMaterials: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
301 let mut m_extraData: _serde::__private::Option<Pointer> = _serde::__private::None;
302 let mut m_properties: _serde::__private::Option<
303 Vec<hkxMaterialProperty>,
304 > = _serde::__private::None;
305 for i in 0..9usize {
306 match i {
307 0usize => {
308 if _serde::__private::Option::is_some(&m_name) {
309 return _serde::__private::Err(
310 <__A::Error as _serde::de::Error>::duplicate_field("name"),
311 );
312 }
313 m_name = _serde::__private::Some(
314 match __A::next_value::<StringPtr<'de>>(&mut __map) {
315 _serde::__private::Ok(__val) => __val,
316 _serde::__private::Err(__err) => {
317 return _serde::__private::Err(__err);
318 }
319 },
320 );
321 }
322 1usize => {
323 if _serde::__private::Option::is_some(&m_stages) {
324 return _serde::__private::Err(
325 <__A::Error as _serde::de::Error>::duplicate_field("stages"),
326 );
327 }
328 m_stages = _serde::__private::Some(
329 match __A::next_value::<
330 Vec<hkxMaterialTextureStage>,
331 >(&mut __map) {
332 _serde::__private::Ok(__val) => __val,
333 _serde::__private::Err(__err) => {
334 return _serde::__private::Err(__err);
335 }
336 },
337 );
338 }
339 2usize => {
340 if _serde::__private::Option::is_some(&m_diffuseColor) {
341 return _serde::__private::Err(
342 <__A::Error as _serde::de::Error>::duplicate_field(
343 "diffuseColor",
344 ),
345 );
346 }
347 __A::pad(&mut __map, 12usize, 8usize)?;
348 m_diffuseColor = _serde::__private::Some(
349 match __A::next_value::<Vector4>(&mut __map) {
350 _serde::__private::Ok(__val) => __val,
351 _serde::__private::Err(__err) => {
352 return _serde::__private::Err(__err);
353 }
354 },
355 );
356 }
357 3usize => {
358 if _serde::__private::Option::is_some(&m_ambientColor) {
359 return _serde::__private::Err(
360 <__A::Error as _serde::de::Error>::duplicate_field(
361 "ambientColor",
362 ),
363 );
364 }
365 m_ambientColor = _serde::__private::Some(
366 match __A::next_value::<Vector4>(&mut __map) {
367 _serde::__private::Ok(__val) => __val,
368 _serde::__private::Err(__err) => {
369 return _serde::__private::Err(__err);
370 }
371 },
372 );
373 }
374 4usize => {
375 if _serde::__private::Option::is_some(&m_specularColor) {
376 return _serde::__private::Err(
377 <__A::Error as _serde::de::Error>::duplicate_field(
378 "specularColor",
379 ),
380 );
381 }
382 m_specularColor = _serde::__private::Some(
383 match __A::next_value::<Vector4>(&mut __map) {
384 _serde::__private::Ok(__val) => __val,
385 _serde::__private::Err(__err) => {
386 return _serde::__private::Err(__err);
387 }
388 },
389 );
390 }
391 5usize => {
392 if _serde::__private::Option::is_some(&m_emissiveColor) {
393 return _serde::__private::Err(
394 <__A::Error as _serde::de::Error>::duplicate_field(
395 "emissiveColor",
396 ),
397 );
398 }
399 m_emissiveColor = _serde::__private::Some(
400 match __A::next_value::<Vector4>(&mut __map) {
401 _serde::__private::Ok(__val) => __val,
402 _serde::__private::Err(__err) => {
403 return _serde::__private::Err(__err);
404 }
405 },
406 );
407 }
408 6usize => {
409 if _serde::__private::Option::is_some(&m_subMaterials) {
410 return _serde::__private::Err(
411 <__A::Error as _serde::de::Error>::duplicate_field(
412 "subMaterials",
413 ),
414 );
415 }
416 m_subMaterials = _serde::__private::Some(
417 match __A::next_value::<Vec<Pointer>>(&mut __map) {
418 _serde::__private::Ok(__val) => __val,
419 _serde::__private::Err(__err) => {
420 return _serde::__private::Err(__err);
421 }
422 },
423 );
424 }
425 7usize => {
426 if _serde::__private::Option::is_some(&m_extraData) {
427 return _serde::__private::Err(
428 <__A::Error as _serde::de::Error>::duplicate_field(
429 "extraData",
430 ),
431 );
432 }
433 m_extraData = _serde::__private::Some(
434 match __A::next_value::<Pointer>(&mut __map) {
435 _serde::__private::Ok(__val) => __val,
436 _serde::__private::Err(__err) => {
437 return _serde::__private::Err(__err);
438 }
439 },
440 );
441 }
442 8usize => {
443 if _serde::__private::Option::is_some(&m_properties) {
444 return _serde::__private::Err(
445 <__A::Error as _serde::de::Error>::duplicate_field(
446 "properties",
447 ),
448 );
449 }
450 m_properties = _serde::__private::Some(
451 match __A::next_value::<
452 Vec<hkxMaterialProperty>,
453 >(&mut __map) {
454 _serde::__private::Ok(__val) => __val,
455 _serde::__private::Err(__err) => {
456 return _serde::__private::Err(__err);
457 }
458 },
459 );
460 }
461 _ => {}
462 }
463 }
464 __A::pad(&mut __map, 4usize, 8usize)?;
465 let m_name = match m_name {
466 _serde::__private::Some(__field) => __field,
467 _serde::__private::None => {
468 return _serde::__private::Err(
469 <__A::Error as _serde::de::Error>::missing_field("name"),
470 );
471 }
472 };
473 let m_stages = match m_stages {
474 _serde::__private::Some(__field) => __field,
475 _serde::__private::None => {
476 return _serde::__private::Err(
477 <__A::Error as _serde::de::Error>::missing_field("stages"),
478 );
479 }
480 };
481 let m_diffuseColor = match m_diffuseColor {
482 _serde::__private::Some(__field) => __field,
483 _serde::__private::None => {
484 return _serde::__private::Err(
485 <__A::Error as _serde::de::Error>::missing_field(
486 "diffuseColor",
487 ),
488 );
489 }
490 };
491 let m_ambientColor = match m_ambientColor {
492 _serde::__private::Some(__field) => __field,
493 _serde::__private::None => {
494 return _serde::__private::Err(
495 <__A::Error as _serde::de::Error>::missing_field(
496 "ambientColor",
497 ),
498 );
499 }
500 };
501 let m_specularColor = match m_specularColor {
502 _serde::__private::Some(__field) => __field,
503 _serde::__private::None => {
504 return _serde::__private::Err(
505 <__A::Error as _serde::de::Error>::missing_field(
506 "specularColor",
507 ),
508 );
509 }
510 };
511 let m_emissiveColor = match m_emissiveColor {
512 _serde::__private::Some(__field) => __field,
513 _serde::__private::None => {
514 return _serde::__private::Err(
515 <__A::Error as _serde::de::Error>::missing_field(
516 "emissiveColor",
517 ),
518 );
519 }
520 };
521 let m_subMaterials = match m_subMaterials {
522 _serde::__private::Some(__field) => __field,
523 _serde::__private::None => {
524 return _serde::__private::Err(
525 <__A::Error as _serde::de::Error>::missing_field(
526 "subMaterials",
527 ),
528 );
529 }
530 };
531 let m_extraData = match m_extraData {
532 _serde::__private::Some(__field) => __field,
533 _serde::__private::None => {
534 return _serde::__private::Err(
535 <__A::Error as _serde::de::Error>::missing_field(
536 "extraData",
537 ),
538 );
539 }
540 };
541 let m_properties = match m_properties {
542 _serde::__private::Some(__field) => __field,
543 _serde::__private::None => {
544 return _serde::__private::Err(
545 <__A::Error as _serde::de::Error>::missing_field(
546 "properties",
547 ),
548 );
549 }
550 };
551 _serde::__private::Ok(hkxMaterial {
552 __ptr,
553 parent,
554 m_name,
555 m_stages,
556 m_diffuseColor,
557 m_ambientColor,
558 m_specularColor,
559 m_emissiveColor,
560 m_subMaterials,
561 m_extraData,
562 m_properties,
563 })
564 }
565 #[allow(clippy::manual_unwrap_or_default)]
566 fn visit_struct<__A>(
567 self,
568 mut __map: __A,
569 ) -> _serde::__private::Result<Self::Value, __A::Error>
570 where
571 __A: _serde::de::MapAccess<'de>,
572 {
573 let mut m_attributeGroups: _serde::__private::Option<
574 Vec<hkxAttributeGroup<'de>>,
575 > = _serde::__private::None;
576 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
577 let mut m_stages: _serde::__private::Option<
578 Vec<hkxMaterialTextureStage>,
579 > = _serde::__private::None;
580 let mut m_diffuseColor: _serde::__private::Option<Vector4> = _serde::__private::None;
581 let mut m_ambientColor: _serde::__private::Option<Vector4> = _serde::__private::None;
582 let mut m_specularColor: _serde::__private::Option<Vector4> = _serde::__private::None;
583 let mut m_emissiveColor: _serde::__private::Option<Vector4> = _serde::__private::None;
584 let mut m_subMaterials: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
585 let mut m_extraData: _serde::__private::Option<Pointer> = _serde::__private::None;
586 let mut m_properties: _serde::__private::Option<
587 Vec<hkxMaterialProperty>,
588 > = _serde::__private::None;
589 while let _serde::__private::Some(__key) = {
590 __A::next_key::<__Field>(&mut __map)?
591 } {
592 match __key {
593 __Field::m_attributeGroups => {
594 #[cfg(
595 any(feature = "strict", feature = "ignore_duplicates")
596 )]
597 if _serde::__private::Option::is_some(&m_attributeGroups) {
598 #[cfg(feature = "ignore_duplicates")]
599 {
600 __A::skip_value(&mut __map)?;
601 continue;
602 }
603 #[cfg(feature = "strict")]
604 return _serde::__private::Err(
605 <__A::Error as _serde::de::Error>::duplicate_field(
606 "attributeGroups",
607 ),
608 );
609 }
610 m_attributeGroups = _serde::__private::Some(
611 match __A::next_value::<
612 Vec<hkxAttributeGroup<'de>>,
613 >(&mut __map) {
614 _serde::__private::Ok(__val) => __val,
615 _serde::__private::Err(__err) => {
616 return _serde::__private::Err(__err);
617 }
618 },
619 );
620 }
621 __Field::m_name => {
622 #[cfg(
623 any(feature = "strict", feature = "ignore_duplicates")
624 )]
625 if _serde::__private::Option::is_some(&m_name) {
626 #[cfg(feature = "ignore_duplicates")]
627 {
628 __A::skip_value(&mut __map)?;
629 continue;
630 }
631 #[cfg(feature = "strict")]
632 return _serde::__private::Err(
633 <__A::Error as _serde::de::Error>::duplicate_field("name"),
634 );
635 }
636 m_name = _serde::__private::Some(
637 match __A::next_value::<StringPtr<'de>>(&mut __map) {
638 _serde::__private::Ok(__val) => __val,
639 _serde::__private::Err(__err) => {
640 return _serde::__private::Err(__err);
641 }
642 },
643 );
644 }
645 __Field::m_stages => {
646 #[cfg(
647 any(feature = "strict", feature = "ignore_duplicates")
648 )]
649 if _serde::__private::Option::is_some(&m_stages) {
650 #[cfg(feature = "ignore_duplicates")]
651 {
652 __A::skip_value(&mut __map)?;
653 continue;
654 }
655 #[cfg(feature = "strict")]
656 return _serde::__private::Err(
657 <__A::Error as _serde::de::Error>::duplicate_field("stages"),
658 );
659 }
660 m_stages = _serde::__private::Some(
661 match __A::next_value::<
662 Vec<hkxMaterialTextureStage>,
663 >(&mut __map) {
664 _serde::__private::Ok(__val) => __val,
665 _serde::__private::Err(__err) => {
666 return _serde::__private::Err(__err);
667 }
668 },
669 );
670 }
671 __Field::m_diffuseColor => {
672 #[cfg(
673 any(feature = "strict", feature = "ignore_duplicates")
674 )]
675 if _serde::__private::Option::is_some(&m_diffuseColor) {
676 #[cfg(feature = "ignore_duplicates")]
677 {
678 __A::skip_value(&mut __map)?;
679 continue;
680 }
681 #[cfg(feature = "strict")]
682 return _serde::__private::Err(
683 <__A::Error as _serde::de::Error>::duplicate_field(
684 "diffuseColor",
685 ),
686 );
687 }
688 m_diffuseColor = _serde::__private::Some(
689 match __A::next_value::<Vector4>(&mut __map) {
690 _serde::__private::Ok(__val) => __val,
691 _serde::__private::Err(__err) => {
692 return _serde::__private::Err(__err);
693 }
694 },
695 );
696 }
697 __Field::m_ambientColor => {
698 #[cfg(
699 any(feature = "strict", feature = "ignore_duplicates")
700 )]
701 if _serde::__private::Option::is_some(&m_ambientColor) {
702 #[cfg(feature = "ignore_duplicates")]
703 {
704 __A::skip_value(&mut __map)?;
705 continue;
706 }
707 #[cfg(feature = "strict")]
708 return _serde::__private::Err(
709 <__A::Error as _serde::de::Error>::duplicate_field(
710 "ambientColor",
711 ),
712 );
713 }
714 m_ambientColor = _serde::__private::Some(
715 match __A::next_value::<Vector4>(&mut __map) {
716 _serde::__private::Ok(__val) => __val,
717 _serde::__private::Err(__err) => {
718 return _serde::__private::Err(__err);
719 }
720 },
721 );
722 }
723 __Field::m_specularColor => {
724 #[cfg(
725 any(feature = "strict", feature = "ignore_duplicates")
726 )]
727 if _serde::__private::Option::is_some(&m_specularColor) {
728 #[cfg(feature = "ignore_duplicates")]
729 {
730 __A::skip_value(&mut __map)?;
731 continue;
732 }
733 #[cfg(feature = "strict")]
734 return _serde::__private::Err(
735 <__A::Error as _serde::de::Error>::duplicate_field(
736 "specularColor",
737 ),
738 );
739 }
740 m_specularColor = _serde::__private::Some(
741 match __A::next_value::<Vector4>(&mut __map) {
742 _serde::__private::Ok(__val) => __val,
743 _serde::__private::Err(__err) => {
744 return _serde::__private::Err(__err);
745 }
746 },
747 );
748 }
749 __Field::m_emissiveColor => {
750 #[cfg(
751 any(feature = "strict", feature = "ignore_duplicates")
752 )]
753 if _serde::__private::Option::is_some(&m_emissiveColor) {
754 #[cfg(feature = "ignore_duplicates")]
755 {
756 __A::skip_value(&mut __map)?;
757 continue;
758 }
759 #[cfg(feature = "strict")]
760 return _serde::__private::Err(
761 <__A::Error as _serde::de::Error>::duplicate_field(
762 "emissiveColor",
763 ),
764 );
765 }
766 m_emissiveColor = _serde::__private::Some(
767 match __A::next_value::<Vector4>(&mut __map) {
768 _serde::__private::Ok(__val) => __val,
769 _serde::__private::Err(__err) => {
770 return _serde::__private::Err(__err);
771 }
772 },
773 );
774 }
775 __Field::m_subMaterials => {
776 #[cfg(
777 any(feature = "strict", feature = "ignore_duplicates")
778 )]
779 if _serde::__private::Option::is_some(&m_subMaterials) {
780 #[cfg(feature = "ignore_duplicates")]
781 {
782 __A::skip_value(&mut __map)?;
783 continue;
784 }
785 #[cfg(feature = "strict")]
786 return _serde::__private::Err(
787 <__A::Error as _serde::de::Error>::duplicate_field(
788 "subMaterials",
789 ),
790 );
791 }
792 m_subMaterials = _serde::__private::Some(
793 match __A::next_value::<Vec<Pointer>>(&mut __map) {
794 _serde::__private::Ok(__val) => __val,
795 _serde::__private::Err(__err) => {
796 return _serde::__private::Err(__err);
797 }
798 },
799 );
800 }
801 __Field::m_extraData => {
802 #[cfg(
803 any(feature = "strict", feature = "ignore_duplicates")
804 )]
805 if _serde::__private::Option::is_some(&m_extraData) {
806 #[cfg(feature = "ignore_duplicates")]
807 {
808 __A::skip_value(&mut __map)?;
809 continue;
810 }
811 #[cfg(feature = "strict")]
812 return _serde::__private::Err(
813 <__A::Error as _serde::de::Error>::duplicate_field(
814 "extraData",
815 ),
816 );
817 }
818 m_extraData = _serde::__private::Some(
819 match __A::next_value::<Pointer>(&mut __map) {
820 _serde::__private::Ok(__val) => __val,
821 _serde::__private::Err(__err) => {
822 return _serde::__private::Err(__err);
823 }
824 },
825 );
826 }
827 __Field::m_properties => {
828 #[cfg(
829 any(feature = "strict", feature = "ignore_duplicates")
830 )]
831 if _serde::__private::Option::is_some(&m_properties) {
832 #[cfg(feature = "ignore_duplicates")]
833 {
834 __A::skip_value(&mut __map)?;
835 continue;
836 }
837 #[cfg(feature = "strict")]
838 return _serde::__private::Err(
839 <__A::Error as _serde::de::Error>::duplicate_field(
840 "properties",
841 ),
842 );
843 }
844 m_properties = _serde::__private::Some(
845 match __A::next_value::<
846 Vec<hkxMaterialProperty>,
847 >(&mut __map) {
848 _serde::__private::Ok(__val) => __val,
849 _serde::__private::Err(__err) => {
850 return _serde::__private::Err(__err);
851 }
852 },
853 );
854 }
855 _ => __A::skip_value(&mut __map)?,
856 }
857 }
858 let m_attributeGroups = match m_attributeGroups {
859 _serde::__private::Some(__field) => __field,
860 _serde::__private::None => {
861 #[cfg(feature = "strict")]
862 return _serde::__private::Err(
863 <__A::Error as _serde::de::Error>::missing_field(
864 "attributeGroups",
865 ),
866 );
867 #[cfg(not(feature = "strict"))] Default::default()
868 }
869 };
870 let m_name = match m_name {
871 _serde::__private::Some(__field) => __field,
872 _serde::__private::None => {
873 #[cfg(feature = "strict")]
874 return _serde::__private::Err(
875 <__A::Error as _serde::de::Error>::missing_field("name"),
876 );
877 #[cfg(not(feature = "strict"))] Default::default()
878 }
879 };
880 let m_stages = match m_stages {
881 _serde::__private::Some(__field) => __field,
882 _serde::__private::None => {
883 #[cfg(feature = "strict")]
884 return _serde::__private::Err(
885 <__A::Error as _serde::de::Error>::missing_field("stages"),
886 );
887 #[cfg(not(feature = "strict"))] Default::default()
888 }
889 };
890 let m_diffuseColor = match m_diffuseColor {
891 _serde::__private::Some(__field) => __field,
892 _serde::__private::None => {
893 #[cfg(feature = "strict")]
894 return _serde::__private::Err(
895 <__A::Error as _serde::de::Error>::missing_field(
896 "diffuseColor",
897 ),
898 );
899 #[cfg(not(feature = "strict"))] Default::default()
900 }
901 };
902 let m_ambientColor = match m_ambientColor {
903 _serde::__private::Some(__field) => __field,
904 _serde::__private::None => {
905 #[cfg(feature = "strict")]
906 return _serde::__private::Err(
907 <__A::Error as _serde::de::Error>::missing_field(
908 "ambientColor",
909 ),
910 );
911 #[cfg(not(feature = "strict"))] Default::default()
912 }
913 };
914 let m_specularColor = match m_specularColor {
915 _serde::__private::Some(__field) => __field,
916 _serde::__private::None => {
917 #[cfg(feature = "strict")]
918 return _serde::__private::Err(
919 <__A::Error as _serde::de::Error>::missing_field(
920 "specularColor",
921 ),
922 );
923 #[cfg(not(feature = "strict"))] Default::default()
924 }
925 };
926 let m_emissiveColor = match m_emissiveColor {
927 _serde::__private::Some(__field) => __field,
928 _serde::__private::None => {
929 #[cfg(feature = "strict")]
930 return _serde::__private::Err(
931 <__A::Error as _serde::de::Error>::missing_field(
932 "emissiveColor",
933 ),
934 );
935 #[cfg(not(feature = "strict"))] Default::default()
936 }
937 };
938 let m_subMaterials = match m_subMaterials {
939 _serde::__private::Some(__field) => __field,
940 _serde::__private::None => {
941 #[cfg(feature = "strict")]
942 return _serde::__private::Err(
943 <__A::Error as _serde::de::Error>::missing_field(
944 "subMaterials",
945 ),
946 );
947 #[cfg(not(feature = "strict"))] Default::default()
948 }
949 };
950 let m_extraData = match m_extraData {
951 _serde::__private::Some(__field) => __field,
952 _serde::__private::None => {
953 #[cfg(feature = "strict")]
954 return _serde::__private::Err(
955 <__A::Error as _serde::de::Error>::missing_field(
956 "extraData",
957 ),
958 );
959 #[cfg(not(feature = "strict"))] Default::default()
960 }
961 };
962 let m_properties = match m_properties {
963 _serde::__private::Some(__field) => __field,
964 _serde::__private::None => {
965 #[cfg(feature = "strict")]
966 return _serde::__private::Err(
967 <__A::Error as _serde::de::Error>::missing_field(
968 "properties",
969 ),
970 );
971 #[cfg(not(feature = "strict"))] Default::default()
972 }
973 };
974 let __ptr = None;
975 let parent = hkBaseObject { __ptr };
976 let parent = hkReferencedObject {
977 __ptr,
978 parent,
979 ..Default::default()
980 };
981 let parent = hkxAttributeHolder {
982 __ptr,
983 parent,
984 m_attributeGroups,
985 };
986 let __ptr = __A::class_ptr(&mut __map);
987 _serde::__private::Ok(hkxMaterial {
988 __ptr,
989 parent,
990 m_name,
991 m_stages,
992 m_diffuseColor,
993 m_ambientColor,
994 m_specularColor,
995 m_emissiveColor,
996 m_subMaterials,
997 m_extraData,
998 m_properties,
999 })
1000 }
1001 }
1002 const FIELDS: &[&str] = &[
1003 "name",
1004 "stages",
1005 "diffuseColor",
1006 "ambientColor",
1007 "specularColor",
1008 "emissiveColor",
1009 "subMaterials",
1010 "extraData",
1011 "properties",
1012 ];
1013 _serde::Deserializer::deserialize_struct(
1014 deserializer,
1015 "hkxMaterial",
1016 FIELDS,
1017 __hkxMaterialVisitor {
1018 marker: _serde::__private::PhantomData::<hkxMaterial>,
1019 lifetime: _serde::__private::PhantomData,
1020 },
1021 )
1022 }
1023 }
1024};
1025#[allow(non_upper_case_globals, non_snake_case)]
1028#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1029#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1030#[derive(
1031 Debug,
1032 Clone,
1033 Default,
1034 PartialEq,
1035 Eq,
1036 PartialOrd,
1037 Ord,
1038 num_derive::ToPrimitive,
1039 num_derive::FromPrimitive,
1040)]
1041pub enum TextureType {
1042 #[default]
1043 TEX_UNKNOWN = 0isize,
1044 TEX_DIFFUSE = 1isize,
1045 TEX_REFLECTION = 2isize,
1046 TEX_BUMP = 3isize,
1047 TEX_NORMAL = 4isize,
1048 TEX_DISPLACEMENT = 5isize,
1049 TEX_SPECULAR = 6isize,
1050 TEX_SPECULARANDGLOSS = 7isize,
1051 TEX_OPACITY = 8isize,
1052 TEX_EMISSIVE = 9isize,
1053 TEX_REFRACTION = 10isize,
1054 TEX_GLOSS = 11isize,
1055 TEX_NOTEXPORTED = 12isize,
1056}
1057const _: () = {
1058 use havok_serde as __serde;
1059 impl __serde::Serialize for TextureType {
1060 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1061 where
1062 S: __serde::ser::Serializer,
1063 {
1064 let mut __serializer = __serializer.serialize_enum_flags()?;
1065 match self {
1066 Self::TEX_UNKNOWN => __serializer.serialize_field("TEX_UNKNOWN", &0u64),
1067 Self::TEX_DIFFUSE => __serializer.serialize_field("TEX_DIFFUSE", &1u64),
1068 Self::TEX_REFLECTION => {
1069 __serializer.serialize_field("TEX_REFLECTION", &2u64)
1070 }
1071 Self::TEX_BUMP => __serializer.serialize_field("TEX_BUMP", &3u64),
1072 Self::TEX_NORMAL => __serializer.serialize_field("TEX_NORMAL", &4u64),
1073 Self::TEX_DISPLACEMENT => {
1074 __serializer.serialize_field("TEX_DISPLACEMENT", &5u64)
1075 }
1076 Self::TEX_SPECULAR => __serializer.serialize_field("TEX_SPECULAR", &6u64),
1077 Self::TEX_SPECULARANDGLOSS => {
1078 __serializer.serialize_field("TEX_SPECULARANDGLOSS", &7u64)
1079 }
1080 Self::TEX_OPACITY => __serializer.serialize_field("TEX_OPACITY", &8u64),
1081 Self::TEX_EMISSIVE => __serializer.serialize_field("TEX_EMISSIVE", &9u64),
1082 Self::TEX_REFRACTION => {
1083 __serializer.serialize_field("TEX_REFRACTION", &10u64)
1084 }
1085 Self::TEX_GLOSS => __serializer.serialize_field("TEX_GLOSS", &11u64),
1086 Self::TEX_NOTEXPORTED => {
1087 __serializer.serialize_field("TEX_NOTEXPORTED", &12u64)
1088 }
1089 }?;
1090 use num_traits::ToPrimitive as _;
1091 let num = self
1092 .to_i32()
1093 .ok_or(S::Error::custom("Failed enum TextureType to_i32"))?;
1094 __serializer.serialize_bits(&num)?;
1095 __serializer.end()
1096 }
1097 }
1098};
1099#[doc(hidden)]
1100#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1101const _: () = {
1102 #[allow(unused_extern_crates, clippy::useless_attribute)]
1103 extern crate havok_serde as _serde;
1104 #[automatically_derived]
1105 impl<'de> _serde::Deserialize<'de> for TextureType {
1106 fn deserialize<__D>(
1107 __deserializer: __D,
1108 ) -> _serde::__private::Result<Self, __D::Error>
1109 where
1110 __D: _serde::Deserializer<'de>,
1111 {
1112 #[allow(non_camel_case_types)]
1113 #[doc(hidden)]
1114 enum __Field {
1115 __field0,
1116 __field1,
1117 __field2,
1118 __field3,
1119 __field4,
1120 __field5,
1121 __field6,
1122 __field7,
1123 __field8,
1124 __field9,
1125 __field10,
1126 __field11,
1127 __field12,
1128 }
1129 #[doc(hidden)]
1130 struct __FieldVisitor;
1131 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1132 type Value = __Field;
1133 fn expecting(
1134 &self,
1135 __formatter: &mut _serde::__private::Formatter,
1136 ) -> _serde::__private::fmt::Result {
1137 _serde::__private::Formatter::write_str(
1138 __formatter,
1139 "variant identifier",
1140 )
1141 }
1142 fn visit_int32<__E>(
1143 self,
1144 __value: i32,
1145 ) -> _serde::__private::Result<Self::Value, __E>
1146 where
1147 __E: _serde::de::Error,
1148 {
1149 match __value {
1150 0i32 => _serde::__private::Ok(__Field::__field0),
1151 1i32 => _serde::__private::Ok(__Field::__field1),
1152 2i32 => _serde::__private::Ok(__Field::__field2),
1153 3i32 => _serde::__private::Ok(__Field::__field3),
1154 4i32 => _serde::__private::Ok(__Field::__field4),
1155 5i32 => _serde::__private::Ok(__Field::__field5),
1156 6i32 => _serde::__private::Ok(__Field::__field6),
1157 7i32 => _serde::__private::Ok(__Field::__field7),
1158 8i32 => _serde::__private::Ok(__Field::__field8),
1159 9i32 => _serde::__private::Ok(__Field::__field9),
1160 10i32 => _serde::__private::Ok(__Field::__field10),
1161 11i32 => _serde::__private::Ok(__Field::__field11),
1162 12i32 => _serde::__private::Ok(__Field::__field12),
1163 _ => {
1164 _serde::__private::Err(
1165 _serde::de::Error::invalid_value(
1166 _serde::de::Unexpected::Int32(__value),
1167 &"value(i32) of variant is one of 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12",
1168 ),
1169 )
1170 }
1171 }
1172 }
1173 fn visit_stringptr<__E>(
1174 self,
1175 __value: StringPtr<'de>,
1176 ) -> _serde::__private::Result<Self::Value, __E>
1177 where
1178 __E: _serde::de::Error,
1179 {
1180 if let Some(__value) = __value.into_inner() {
1181 match __value.as_ref() {
1182 v if v == "0" || v.eq_ignore_ascii_case("TEX_UNKNOWN") => {
1183 _serde::__private::Ok(__Field::__field0)
1184 }
1185 v if v == "1" || v.eq_ignore_ascii_case("TEX_DIFFUSE") => {
1186 _serde::__private::Ok(__Field::__field1)
1187 }
1188 v if v == "2" || v.eq_ignore_ascii_case("TEX_REFLECTION") => {
1189 _serde::__private::Ok(__Field::__field2)
1190 }
1191 v if v == "3" || v.eq_ignore_ascii_case("TEX_BUMP") => {
1192 _serde::__private::Ok(__Field::__field3)
1193 }
1194 v if v == "4" || v.eq_ignore_ascii_case("TEX_NORMAL") => {
1195 _serde::__private::Ok(__Field::__field4)
1196 }
1197 v if v == "5"
1198 || v.eq_ignore_ascii_case("TEX_DISPLACEMENT") => {
1199 _serde::__private::Ok(__Field::__field5)
1200 }
1201 v if v == "6" || v.eq_ignore_ascii_case("TEX_SPECULAR") => {
1202 _serde::__private::Ok(__Field::__field6)
1203 }
1204 v if v == "7"
1205 || v.eq_ignore_ascii_case("TEX_SPECULARANDGLOSS") => {
1206 _serde::__private::Ok(__Field::__field7)
1207 }
1208 v if v == "8" || v.eq_ignore_ascii_case("TEX_OPACITY") => {
1209 _serde::__private::Ok(__Field::__field8)
1210 }
1211 v if v == "9" || v.eq_ignore_ascii_case("TEX_EMISSIVE") => {
1212 _serde::__private::Ok(__Field::__field9)
1213 }
1214 v if v == "10"
1215 || v.eq_ignore_ascii_case("TEX_REFRACTION") => {
1216 _serde::__private::Ok(__Field::__field10)
1217 }
1218 v if v == "11" || v.eq_ignore_ascii_case("TEX_GLOSS") => {
1219 _serde::__private::Ok(__Field::__field11)
1220 }
1221 v if v == "12"
1222 || v.eq_ignore_ascii_case("TEX_NOTEXPORTED") => {
1223 _serde::__private::Ok(__Field::__field12)
1224 }
1225 _ => {
1226 _serde::__private::Err(
1227 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1228 )
1229 }
1230 }
1231 } else {
1232 _serde::__private::Err(
1233 _serde::de::Error::unknown_variant("None", VARIANTS),
1234 )
1235 }
1236 }
1237 }
1238 impl<'de> _serde::Deserialize<'de> for __Field {
1239 #[inline]
1240 fn deserialize<__D>(
1241 __deserializer: __D,
1242 ) -> _serde::__private::Result<Self, __D::Error>
1243 where
1244 __D: _serde::Deserializer<'de>,
1245 {
1246 _serde::Deserializer::deserialize_identifier(
1247 __deserializer,
1248 _serde::de::ReadEnumSize::Int32,
1249 __FieldVisitor,
1250 )
1251 }
1252 }
1253 #[doc(hidden)]
1254 struct __Visitor<'de> {
1255 marker: _serde::__private::PhantomData<TextureType>,
1256 lifetime: _serde::__private::PhantomData<&'de ()>,
1257 }
1258 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1259 type Value = TextureType;
1260 fn expecting(
1261 &self,
1262 __formatter: &mut _serde::__private::Formatter,
1263 ) -> _serde::__private::fmt::Result {
1264 _serde::__private::Formatter::write_str(
1265 __formatter,
1266 "enum TextureType",
1267 )
1268 }
1269 fn visit_enum<__A>(
1270 self,
1271 __data: __A,
1272 ) -> _serde::__private::Result<Self::Value, __A::Error>
1273 where
1274 __A: _serde::de::EnumAccess<'de>,
1275 {
1276 match _serde::de::EnumAccess::variant(__data)? {
1277 (__Field::__field0, __variant) => {
1278 _serde::de::VariantAccess::unit_variant(__variant)?;
1279 _serde::__private::Ok(TextureType::TEX_UNKNOWN)
1280 }
1281 (__Field::__field1, __variant) => {
1282 _serde::de::VariantAccess::unit_variant(__variant)?;
1283 _serde::__private::Ok(TextureType::TEX_DIFFUSE)
1284 }
1285 (__Field::__field2, __variant) => {
1286 _serde::de::VariantAccess::unit_variant(__variant)?;
1287 _serde::__private::Ok(TextureType::TEX_REFLECTION)
1288 }
1289 (__Field::__field3, __variant) => {
1290 _serde::de::VariantAccess::unit_variant(__variant)?;
1291 _serde::__private::Ok(TextureType::TEX_BUMP)
1292 }
1293 (__Field::__field4, __variant) => {
1294 _serde::de::VariantAccess::unit_variant(__variant)?;
1295 _serde::__private::Ok(TextureType::TEX_NORMAL)
1296 }
1297 (__Field::__field5, __variant) => {
1298 _serde::de::VariantAccess::unit_variant(__variant)?;
1299 _serde::__private::Ok(TextureType::TEX_DISPLACEMENT)
1300 }
1301 (__Field::__field6, __variant) => {
1302 _serde::de::VariantAccess::unit_variant(__variant)?;
1303 _serde::__private::Ok(TextureType::TEX_SPECULAR)
1304 }
1305 (__Field::__field7, __variant) => {
1306 _serde::de::VariantAccess::unit_variant(__variant)?;
1307 _serde::__private::Ok(TextureType::TEX_SPECULARANDGLOSS)
1308 }
1309 (__Field::__field8, __variant) => {
1310 _serde::de::VariantAccess::unit_variant(__variant)?;
1311 _serde::__private::Ok(TextureType::TEX_OPACITY)
1312 }
1313 (__Field::__field9, __variant) => {
1314 _serde::de::VariantAccess::unit_variant(__variant)?;
1315 _serde::__private::Ok(TextureType::TEX_EMISSIVE)
1316 }
1317 (__Field::__field10, __variant) => {
1318 _serde::de::VariantAccess::unit_variant(__variant)?;
1319 _serde::__private::Ok(TextureType::TEX_REFRACTION)
1320 }
1321 (__Field::__field11, __variant) => {
1322 _serde::de::VariantAccess::unit_variant(__variant)?;
1323 _serde::__private::Ok(TextureType::TEX_GLOSS)
1324 }
1325 (__Field::__field12, __variant) => {
1326 _serde::de::VariantAccess::unit_variant(__variant)?;
1327 _serde::__private::Ok(TextureType::TEX_NOTEXPORTED)
1328 }
1329 }
1330 }
1331 }
1332 #[doc(hidden)]
1333 const VARIANTS: &'static [&'static str] = &[
1334 "TEX_UNKNOWN",
1335 "TEX_DIFFUSE",
1336 "TEX_REFLECTION",
1337 "TEX_BUMP",
1338 "TEX_NORMAL",
1339 "TEX_DISPLACEMENT",
1340 "TEX_SPECULAR",
1341 "TEX_SPECULARANDGLOSS",
1342 "TEX_OPACITY",
1343 "TEX_EMISSIVE",
1344 "TEX_REFRACTION",
1345 "TEX_GLOSS",
1346 "TEX_NOTEXPORTED",
1347 ];
1348 _serde::Deserializer::deserialize_enum(
1349 __deserializer,
1350 "TextureType",
1351 VARIANTS,
1352 __Visitor {
1353 marker: _serde::__private::PhantomData::<TextureType>,
1354 lifetime: _serde::__private::PhantomData,
1355 },
1356 )
1357 }
1358 }
1359};