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