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