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