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 hkpStorageMeshShapeSubpartStorage {
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 = "json_schema", schemars(rename = "vertices"))]
35 #[cfg_attr(feature = "serde", serde(rename = "vertices"))]
36 pub m_vertices: Vec<f32>,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "indices16"))]
42 #[cfg_attr(feature = "serde", serde(rename = "indices16"))]
43 pub m_indices16: Vec<u16>,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "indices32"))]
49 #[cfg_attr(feature = "serde", serde(rename = "indices32"))]
50 pub m_indices32: Vec<u32>,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "materialIndices"))]
56 #[cfg_attr(feature = "serde", serde(rename = "materialIndices"))]
57 pub m_materialIndices: Vec<u8>,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "materials"))]
63 #[cfg_attr(feature = "serde", serde(rename = "materials"))]
64 pub m_materials: Vec<u32>,
65 #[cfg_attr(feature = "json_schema", schemars(rename = "materialIndices16"))]
70 #[cfg_attr(feature = "serde", serde(rename = "materialIndices16"))]
71 pub m_materialIndices16: Vec<u16>,
72}
73const _: () = {
74 use havok_serde as _serde;
75 impl _serde::HavokClass for hkpStorageMeshShapeSubpartStorage {
76 #[inline]
77 fn name(&self) -> &'static str {
78 "hkpStorageMeshShapeSubpartStorage"
79 }
80 #[inline]
81 fn signature(&self) -> _serde::__private::Signature {
82 _serde::__private::Signature::new(0xbf27438)
83 }
84 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
85 fn deps_indexes(&self) -> Vec<usize> {
86 let mut v = Vec::new();
87 v
88 }
89 }
90 impl _serde::Serialize for hkpStorageMeshShapeSubpartStorage {
91 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
92 where
93 S: _serde::ser::Serializer,
94 {
95 let class_meta = self
96 .__ptr
97 .map(|name| (name, _serde::__private::Signature::new(0xbf27438)));
98 let mut serializer = __serializer
99 .serialize_struct(
100 "hkpStorageMeshShapeSubpartStorage",
101 class_meta,
102 (80u64, 112u64),
103 )?;
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
109 .serialize_array_field("vertices", &self.m_vertices, TypeSize::NonPtr)?;
110 serializer
111 .serialize_array_field(
112 "indices16",
113 &self.m_indices16,
114 TypeSize::NonPtr,
115 )?;
116 serializer
117 .serialize_array_field(
118 "indices32",
119 &self.m_indices32,
120 TypeSize::NonPtr,
121 )?;
122 serializer
123 .serialize_array_field(
124 "materialIndices",
125 &self.m_materialIndices,
126 TypeSize::NonPtr,
127 )?;
128 serializer
129 .serialize_array_field(
130 "materials",
131 &self.m_materials,
132 TypeSize::NonPtr,
133 )?;
134 serializer
135 .serialize_array_field(
136 "materialIndices16",
137 &self.m_materialIndices16,
138 TypeSize::NonPtr,
139 )?;
140 serializer.end()
141 }
142 }
143};
144#[doc(hidden)]
145#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
146const _: () = {
147 use havok_serde as _serde;
148 #[automatically_derived]
149 impl<'de> _serde::Deserialize<'de> for hkpStorageMeshShapeSubpartStorage {
150 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
151 where
152 __D: _serde::Deserializer<'de>,
153 {
154 #[allow(non_camel_case_types)]
155 enum __Field {
156 m_vertices,
157 m_indices16,
158 m_indices32,
159 m_materialIndices,
160 m_materials,
161 m_materialIndices16,
162 __ignore,
163 }
164 struct __FieldVisitor;
165 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
166 type Value = __Field;
167 fn expecting(
168 &self,
169 __formatter: &mut core::fmt::Formatter,
170 ) -> core::fmt::Result {
171 core::fmt::Formatter::write_str(__formatter, "field identifier")
172 }
173 #[allow(clippy::match_single_binding)]
175 #[allow(clippy::reversed_empty_ranges)]
176 #[allow(clippy::single_match)]
177 fn visit_key<__E>(
178 self,
179 __value: &str,
180 ) -> core::result::Result<Self::Value, __E>
181 where
182 __E: _serde::de::Error,
183 {
184 match __value {
185 "vertices" => Ok(__Field::m_vertices),
186 "indices16" => Ok(__Field::m_indices16),
187 "indices32" => Ok(__Field::m_indices32),
188 "materialIndices" => Ok(__Field::m_materialIndices),
189 "materials" => Ok(__Field::m_materials),
190 "materialIndices16" => Ok(__Field::m_materialIndices16),
191 _ => Ok(__Field::__ignore),
192 }
193 }
194 }
195 impl<'de> _serde::Deserialize<'de> for __Field {
196 #[inline]
197 fn deserialize<__D>(
198 __deserializer: __D,
199 ) -> core::result::Result<Self, __D::Error>
200 where
201 __D: _serde::Deserializer<'de>,
202 {
203 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
204 }
205 }
206 struct __hkpStorageMeshShapeSubpartStorageVisitor<'de> {
207 marker: _serde::__private::PhantomData<
208 hkpStorageMeshShapeSubpartStorage,
209 >,
210 lifetime: _serde::__private::PhantomData<&'de ()>,
211 }
212 #[allow(clippy::match_single_binding)]
213 #[allow(clippy::reversed_empty_ranges)]
214 #[allow(clippy::single_match)]
215 impl<'de> _serde::de::Visitor<'de>
216 for __hkpStorageMeshShapeSubpartStorageVisitor<'de> {
217 type Value = hkpStorageMeshShapeSubpartStorage;
218 fn expecting(
219 &self,
220 __formatter: &mut core::fmt::Formatter,
221 ) -> core::fmt::Result {
222 core::fmt::Formatter::write_str(
223 __formatter,
224 "struct hkpStorageMeshShapeSubpartStorage",
225 )
226 }
227 fn visit_struct_for_bytes<__A>(
228 self,
229 mut __map: __A,
230 ) -> _serde::__private::Result<Self::Value, __A::Error>
231 where
232 __A: _serde::de::MapAccess<'de>,
233 {
234 let __ptr = __A::class_ptr(&mut __map);
235 let parent = __A::parent_value(&mut __map)?;
236 let mut m_vertices: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
237 let mut m_indices16: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
238 let mut m_indices32: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
239 let mut m_materialIndices: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
240 let mut m_materials: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
241 let mut m_materialIndices16: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
242 for i in 0..6usize {
243 match i {
244 0usize => {
245 if _serde::__private::Option::is_some(&m_vertices) {
246 return _serde::__private::Err(
247 <__A::Error as _serde::de::Error>::duplicate_field(
248 "vertices",
249 ),
250 );
251 }
252 m_vertices = _serde::__private::Some(
253 match __A::next_value::<Vec<f32>>(&mut __map) {
254 _serde::__private::Ok(__val) => __val,
255 _serde::__private::Err(__err) => {
256 return _serde::__private::Err(__err);
257 }
258 },
259 );
260 }
261 1usize => {
262 if _serde::__private::Option::is_some(&m_indices16) {
263 return _serde::__private::Err(
264 <__A::Error as _serde::de::Error>::duplicate_field(
265 "indices16",
266 ),
267 );
268 }
269 m_indices16 = _serde::__private::Some(
270 match __A::next_value::<Vec<u16>>(&mut __map) {
271 _serde::__private::Ok(__val) => __val,
272 _serde::__private::Err(__err) => {
273 return _serde::__private::Err(__err);
274 }
275 },
276 );
277 }
278 2usize => {
279 if _serde::__private::Option::is_some(&m_indices32) {
280 return _serde::__private::Err(
281 <__A::Error as _serde::de::Error>::duplicate_field(
282 "indices32",
283 ),
284 );
285 }
286 m_indices32 = _serde::__private::Some(
287 match __A::next_value::<Vec<u32>>(&mut __map) {
288 _serde::__private::Ok(__val) => __val,
289 _serde::__private::Err(__err) => {
290 return _serde::__private::Err(__err);
291 }
292 },
293 );
294 }
295 3usize => {
296 if _serde::__private::Option::is_some(&m_materialIndices) {
297 return _serde::__private::Err(
298 <__A::Error as _serde::de::Error>::duplicate_field(
299 "materialIndices",
300 ),
301 );
302 }
303 m_materialIndices = _serde::__private::Some(
304 match __A::next_value::<Vec<u8>>(&mut __map) {
305 _serde::__private::Ok(__val) => __val,
306 _serde::__private::Err(__err) => {
307 return _serde::__private::Err(__err);
308 }
309 },
310 );
311 }
312 4usize => {
313 if _serde::__private::Option::is_some(&m_materials) {
314 return _serde::__private::Err(
315 <__A::Error as _serde::de::Error>::duplicate_field(
316 "materials",
317 ),
318 );
319 }
320 m_materials = _serde::__private::Some(
321 match __A::next_value::<Vec<u32>>(&mut __map) {
322 _serde::__private::Ok(__val) => __val,
323 _serde::__private::Err(__err) => {
324 return _serde::__private::Err(__err);
325 }
326 },
327 );
328 }
329 5usize => {
330 if _serde::__private::Option::is_some(
331 &m_materialIndices16,
332 ) {
333 return _serde::__private::Err(
334 <__A::Error as _serde::de::Error>::duplicate_field(
335 "materialIndices16",
336 ),
337 );
338 }
339 m_materialIndices16 = _serde::__private::Some(
340 match __A::next_value::<Vec<u16>>(&mut __map) {
341 _serde::__private::Ok(__val) => __val,
342 _serde::__private::Err(__err) => {
343 return _serde::__private::Err(__err);
344 }
345 },
346 );
347 }
348 _ => {}
349 }
350 }
351 let m_vertices = match m_vertices {
352 _serde::__private::Some(__field) => __field,
353 _serde::__private::None => {
354 return _serde::__private::Err(
355 <__A::Error as _serde::de::Error>::missing_field("vertices"),
356 );
357 }
358 };
359 let m_indices16 = match m_indices16 {
360 _serde::__private::Some(__field) => __field,
361 _serde::__private::None => {
362 return _serde::__private::Err(
363 <__A::Error as _serde::de::Error>::missing_field(
364 "indices16",
365 ),
366 );
367 }
368 };
369 let m_indices32 = match m_indices32 {
370 _serde::__private::Some(__field) => __field,
371 _serde::__private::None => {
372 return _serde::__private::Err(
373 <__A::Error as _serde::de::Error>::missing_field(
374 "indices32",
375 ),
376 );
377 }
378 };
379 let m_materialIndices = match m_materialIndices {
380 _serde::__private::Some(__field) => __field,
381 _serde::__private::None => {
382 return _serde::__private::Err(
383 <__A::Error as _serde::de::Error>::missing_field(
384 "materialIndices",
385 ),
386 );
387 }
388 };
389 let m_materials = match m_materials {
390 _serde::__private::Some(__field) => __field,
391 _serde::__private::None => {
392 return _serde::__private::Err(
393 <__A::Error as _serde::de::Error>::missing_field(
394 "materials",
395 ),
396 );
397 }
398 };
399 let m_materialIndices16 = match m_materialIndices16 {
400 _serde::__private::Some(__field) => __field,
401 _serde::__private::None => {
402 return _serde::__private::Err(
403 <__A::Error as _serde::de::Error>::missing_field(
404 "materialIndices16",
405 ),
406 );
407 }
408 };
409 _serde::__private::Ok(hkpStorageMeshShapeSubpartStorage {
410 __ptr,
411 parent,
412 m_vertices,
413 m_indices16,
414 m_indices32,
415 m_materialIndices,
416 m_materials,
417 m_materialIndices16,
418 })
419 }
420 #[allow(clippy::manual_unwrap_or_default)]
421 fn visit_struct<__A>(
422 self,
423 mut __map: __A,
424 ) -> _serde::__private::Result<Self::Value, __A::Error>
425 where
426 __A: _serde::de::MapAccess<'de>,
427 {
428 let mut m_vertices: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
429 let mut m_indices16: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
430 let mut m_indices32: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
431 let mut m_materialIndices: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
432 let mut m_materials: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
433 let mut m_materialIndices16: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
434 while let _serde::__private::Some(__key) = {
435 __A::next_key::<__Field>(&mut __map)?
436 } {
437 match __key {
438 __Field::m_vertices => {
439 #[cfg(
440 any(feature = "strict", feature = "ignore_duplicates")
441 )]
442 if _serde::__private::Option::is_some(&m_vertices) {
443 #[cfg(feature = "ignore_duplicates")]
444 {
445 __A::skip_value(&mut __map)?;
446 continue;
447 }
448 #[cfg(feature = "strict")]
449 return _serde::__private::Err(
450 <__A::Error as _serde::de::Error>::duplicate_field(
451 "vertices",
452 ),
453 );
454 }
455 m_vertices = _serde::__private::Some(
456 match __A::next_value::<Vec<f32>>(&mut __map) {
457 _serde::__private::Ok(__val) => __val,
458 _serde::__private::Err(__err) => {
459 return _serde::__private::Err(__err);
460 }
461 },
462 );
463 }
464 __Field::m_indices16 => {
465 #[cfg(
466 any(feature = "strict", feature = "ignore_duplicates")
467 )]
468 if _serde::__private::Option::is_some(&m_indices16) {
469 #[cfg(feature = "ignore_duplicates")]
470 {
471 __A::skip_value(&mut __map)?;
472 continue;
473 }
474 #[cfg(feature = "strict")]
475 return _serde::__private::Err(
476 <__A::Error as _serde::de::Error>::duplicate_field(
477 "indices16",
478 ),
479 );
480 }
481 m_indices16 = _serde::__private::Some(
482 match __A::next_value::<Vec<u16>>(&mut __map) {
483 _serde::__private::Ok(__val) => __val,
484 _serde::__private::Err(__err) => {
485 return _serde::__private::Err(__err);
486 }
487 },
488 );
489 }
490 __Field::m_indices32 => {
491 #[cfg(
492 any(feature = "strict", feature = "ignore_duplicates")
493 )]
494 if _serde::__private::Option::is_some(&m_indices32) {
495 #[cfg(feature = "ignore_duplicates")]
496 {
497 __A::skip_value(&mut __map)?;
498 continue;
499 }
500 #[cfg(feature = "strict")]
501 return _serde::__private::Err(
502 <__A::Error as _serde::de::Error>::duplicate_field(
503 "indices32",
504 ),
505 );
506 }
507 m_indices32 = _serde::__private::Some(
508 match __A::next_value::<Vec<u32>>(&mut __map) {
509 _serde::__private::Ok(__val) => __val,
510 _serde::__private::Err(__err) => {
511 return _serde::__private::Err(__err);
512 }
513 },
514 );
515 }
516 __Field::m_materialIndices => {
517 #[cfg(
518 any(feature = "strict", feature = "ignore_duplicates")
519 )]
520 if _serde::__private::Option::is_some(&m_materialIndices) {
521 #[cfg(feature = "ignore_duplicates")]
522 {
523 __A::skip_value(&mut __map)?;
524 continue;
525 }
526 #[cfg(feature = "strict")]
527 return _serde::__private::Err(
528 <__A::Error as _serde::de::Error>::duplicate_field(
529 "materialIndices",
530 ),
531 );
532 }
533 m_materialIndices = _serde::__private::Some(
534 match __A::next_value::<Vec<u8>>(&mut __map) {
535 _serde::__private::Ok(__val) => __val,
536 _serde::__private::Err(__err) => {
537 return _serde::__private::Err(__err);
538 }
539 },
540 );
541 }
542 __Field::m_materials => {
543 #[cfg(
544 any(feature = "strict", feature = "ignore_duplicates")
545 )]
546 if _serde::__private::Option::is_some(&m_materials) {
547 #[cfg(feature = "ignore_duplicates")]
548 {
549 __A::skip_value(&mut __map)?;
550 continue;
551 }
552 #[cfg(feature = "strict")]
553 return _serde::__private::Err(
554 <__A::Error as _serde::de::Error>::duplicate_field(
555 "materials",
556 ),
557 );
558 }
559 m_materials = _serde::__private::Some(
560 match __A::next_value::<Vec<u32>>(&mut __map) {
561 _serde::__private::Ok(__val) => __val,
562 _serde::__private::Err(__err) => {
563 return _serde::__private::Err(__err);
564 }
565 },
566 );
567 }
568 __Field::m_materialIndices16 => {
569 #[cfg(
570 any(feature = "strict", feature = "ignore_duplicates")
571 )]
572 if _serde::__private::Option::is_some(
573 &m_materialIndices16,
574 ) {
575 #[cfg(feature = "ignore_duplicates")]
576 {
577 __A::skip_value(&mut __map)?;
578 continue;
579 }
580 #[cfg(feature = "strict")]
581 return _serde::__private::Err(
582 <__A::Error as _serde::de::Error>::duplicate_field(
583 "materialIndices16",
584 ),
585 );
586 }
587 m_materialIndices16 = _serde::__private::Some(
588 match __A::next_value::<Vec<u16>>(&mut __map) {
589 _serde::__private::Ok(__val) => __val,
590 _serde::__private::Err(__err) => {
591 return _serde::__private::Err(__err);
592 }
593 },
594 );
595 }
596 _ => __A::skip_value(&mut __map)?,
597 }
598 }
599 let m_vertices = match m_vertices {
600 _serde::__private::Some(__field) => __field,
601 _serde::__private::None => {
602 #[cfg(feature = "strict")]
603 return _serde::__private::Err(
604 <__A::Error as _serde::de::Error>::missing_field("vertices"),
605 );
606 #[cfg(not(feature = "strict"))] Default::default()
607 }
608 };
609 let m_indices16 = match m_indices16 {
610 _serde::__private::Some(__field) => __field,
611 _serde::__private::None => {
612 #[cfg(feature = "strict")]
613 return _serde::__private::Err(
614 <__A::Error as _serde::de::Error>::missing_field(
615 "indices16",
616 ),
617 );
618 #[cfg(not(feature = "strict"))] Default::default()
619 }
620 };
621 let m_indices32 = match m_indices32 {
622 _serde::__private::Some(__field) => __field,
623 _serde::__private::None => {
624 #[cfg(feature = "strict")]
625 return _serde::__private::Err(
626 <__A::Error as _serde::de::Error>::missing_field(
627 "indices32",
628 ),
629 );
630 #[cfg(not(feature = "strict"))] Default::default()
631 }
632 };
633 let m_materialIndices = match m_materialIndices {
634 _serde::__private::Some(__field) => __field,
635 _serde::__private::None => {
636 #[cfg(feature = "strict")]
637 return _serde::__private::Err(
638 <__A::Error as _serde::de::Error>::missing_field(
639 "materialIndices",
640 ),
641 );
642 #[cfg(not(feature = "strict"))] Default::default()
643 }
644 };
645 let m_materials = match m_materials {
646 _serde::__private::Some(__field) => __field,
647 _serde::__private::None => {
648 #[cfg(feature = "strict")]
649 return _serde::__private::Err(
650 <__A::Error as _serde::de::Error>::missing_field(
651 "materials",
652 ),
653 );
654 #[cfg(not(feature = "strict"))] Default::default()
655 }
656 };
657 let m_materialIndices16 = match m_materialIndices16 {
658 _serde::__private::Some(__field) => __field,
659 _serde::__private::None => {
660 #[cfg(feature = "strict")]
661 return _serde::__private::Err(
662 <__A::Error as _serde::de::Error>::missing_field(
663 "materialIndices16",
664 ),
665 );
666 #[cfg(not(feature = "strict"))] Default::default()
667 }
668 };
669 let __ptr = None;
670 let parent = hkBaseObject { __ptr };
671 let parent = hkReferencedObject {
672 __ptr,
673 parent,
674 ..Default::default()
675 };
676 let __ptr = __A::class_ptr(&mut __map);
677 _serde::__private::Ok(hkpStorageMeshShapeSubpartStorage {
678 __ptr,
679 parent,
680 m_vertices,
681 m_indices16,
682 m_indices32,
683 m_materialIndices,
684 m_materials,
685 m_materialIndices16,
686 })
687 }
688 }
689 const FIELDS: &[&str] = &[
690 "vertices",
691 "indices16",
692 "indices32",
693 "materialIndices",
694 "materials",
695 "materialIndices16",
696 ];
697 _serde::Deserializer::deserialize_struct(
698 deserializer,
699 "hkpStorageMeshShapeSubpartStorage",
700 FIELDS,
701 __hkpStorageMeshShapeSubpartStorageVisitor {
702 marker: _serde::__private::PhantomData::<
703 hkpStorageMeshShapeSubpartStorage,
704 >,
705 lifetime: _serde::__private::PhantomData,
706 },
707 )
708 }
709 }
710};