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