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