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