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