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 hkpSoftContactModifierConstraintAtom {
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: hkpModifierConstraintAtom,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "tau"))]
35 #[cfg_attr(feature = "serde", serde(rename = "tau"))]
36 pub m_tau: f32,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "maxAcceleration"))]
42 #[cfg_attr(feature = "serde", serde(rename = "maxAcceleration"))]
43 pub m_maxAcceleration: f32,
44}
45const _: () = {
46 use havok_serde as _serde;
47 impl _serde::HavokClass for hkpSoftContactModifierConstraintAtom {
48 #[inline]
49 fn name(&self) -> &'static str {
50 "hkpSoftContactModifierConstraintAtom"
51 }
52 #[inline]
53 fn signature(&self) -> _serde::__private::Signature {
54 _serde::__private::Signature::new(0xecb34e27)
55 }
56 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
57 fn deps_indexes(&self) -> Vec<usize> {
58 let mut v = Vec::new();
59 v.push(self.parent.m_child.get());
60 v
61 }
62 }
63 impl _serde::Serialize for hkpSoftContactModifierConstraintAtom {
64 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
65 where
66 S: _serde::ser::Serializer,
67 {
68 let class_meta = self
69 .__ptr
70 .map(|name| (name, _serde::__private::Signature::new(0xecb34e27)));
71 let mut serializer = __serializer
72 .serialize_struct(
73 "hkpSoftContactModifierConstraintAtom",
74 class_meta,
75 (48u64, 64u64),
76 )?;
77 serializer.serialize_field("type", &self.parent.parent.m_type)?;
78 serializer.pad_field([0u8; 14usize].as_slice(), [0u8; 14usize].as_slice())?;
79 serializer
80 .serialize_field("modifierAtomSize", &self.parent.m_modifierAtomSize)?;
81 serializer.serialize_field("childSize", &self.parent.m_childSize)?;
82 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
83 serializer.serialize_field("child", &self.parent.m_child)?;
84 serializer
85 .serialize_fixed_array_field(
86 "pad",
87 self.parent.m_pad.as_slice(),
88 TypeSize::NonPtr,
89 )?;
90 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 8usize].as_slice())?;
91 serializer.serialize_field("tau", &self.m_tau)?;
92 serializer.serialize_field("maxAcceleration", &self.m_maxAcceleration)?;
93 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 8usize].as_slice())?;
94 serializer.end()
95 }
96 }
97};
98#[doc(hidden)]
99#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
100const _: () = {
101 use havok_serde as _serde;
102 #[automatically_derived]
103 impl<'de> _serde::Deserialize<'de> for hkpSoftContactModifierConstraintAtom {
104 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
105 where
106 __D: _serde::Deserializer<'de>,
107 {
108 #[allow(non_camel_case_types)]
109 enum __Field {
110 m_type,
111 m_modifierAtomSize,
112 m_childSize,
113 m_child,
114 m_pad,
115 m_tau,
116 m_maxAcceleration,
117 __ignore,
118 }
119 struct __FieldVisitor;
120 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
121 type Value = __Field;
122 fn expecting(
123 &self,
124 __formatter: &mut core::fmt::Formatter,
125 ) -> core::fmt::Result {
126 core::fmt::Formatter::write_str(__formatter, "field identifier")
127 }
128 #[allow(clippy::match_single_binding)]
130 #[allow(clippy::reversed_empty_ranges)]
131 #[allow(clippy::single_match)]
132 fn visit_key<__E>(
133 self,
134 __value: &str,
135 ) -> core::result::Result<Self::Value, __E>
136 where
137 __E: _serde::de::Error,
138 {
139 match __value {
140 "type" => Ok(__Field::m_type),
141 "modifierAtomSize" => Ok(__Field::m_modifierAtomSize),
142 "childSize" => Ok(__Field::m_childSize),
143 "child" => Ok(__Field::m_child),
144 "pad" => Ok(__Field::m_pad),
145 "tau" => Ok(__Field::m_tau),
146 "maxAcceleration" => Ok(__Field::m_maxAcceleration),
147 _ => Ok(__Field::__ignore),
148 }
149 }
150 }
151 impl<'de> _serde::Deserialize<'de> for __Field {
152 #[inline]
153 fn deserialize<__D>(
154 __deserializer: __D,
155 ) -> core::result::Result<Self, __D::Error>
156 where
157 __D: _serde::Deserializer<'de>,
158 {
159 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
160 }
161 }
162 struct __hkpSoftContactModifierConstraintAtomVisitor<'de> {
163 marker: _serde::__private::PhantomData<
164 hkpSoftContactModifierConstraintAtom,
165 >,
166 lifetime: _serde::__private::PhantomData<&'de ()>,
167 }
168 #[allow(clippy::match_single_binding)]
169 #[allow(clippy::reversed_empty_ranges)]
170 #[allow(clippy::single_match)]
171 impl<'de> _serde::de::Visitor<'de>
172 for __hkpSoftContactModifierConstraintAtomVisitor<'de> {
173 type Value = hkpSoftContactModifierConstraintAtom;
174 fn expecting(
175 &self,
176 __formatter: &mut core::fmt::Formatter,
177 ) -> core::fmt::Result {
178 core::fmt::Formatter::write_str(
179 __formatter,
180 "struct hkpSoftContactModifierConstraintAtom",
181 )
182 }
183 fn visit_struct_for_bytes<__A>(
184 self,
185 mut __map: __A,
186 ) -> _serde::__private::Result<Self::Value, __A::Error>
187 where
188 __A: _serde::de::MapAccess<'de>,
189 {
190 let __ptr = __A::class_ptr(&mut __map);
191 let parent = __A::parent_value(&mut __map)?;
192 let mut m_tau: _serde::__private::Option<f32> = _serde::__private::None;
193 let mut m_maxAcceleration: _serde::__private::Option<f32> = _serde::__private::None;
194 for i in 0..2usize {
195 match i {
196 0usize => {
197 if _serde::__private::Option::is_some(&m_tau) {
198 return _serde::__private::Err(
199 <__A::Error as _serde::de::Error>::duplicate_field("tau"),
200 );
201 }
202 m_tau = _serde::__private::Some(
203 match __A::next_value::<f32>(&mut __map) {
204 _serde::__private::Ok(__val) => __val,
205 _serde::__private::Err(__err) => {
206 return _serde::__private::Err(__err);
207 }
208 },
209 );
210 }
211 1usize => {
212 if _serde::__private::Option::is_some(&m_maxAcceleration) {
213 return _serde::__private::Err(
214 <__A::Error as _serde::de::Error>::duplicate_field(
215 "maxAcceleration",
216 ),
217 );
218 }
219 m_maxAcceleration = _serde::__private::Some(
220 match __A::next_value::<f32>(&mut __map) {
221 _serde::__private::Ok(__val) => __val,
222 _serde::__private::Err(__err) => {
223 return _serde::__private::Err(__err);
224 }
225 },
226 );
227 }
228 _ => {}
229 }
230 }
231 __A::pad(&mut __map, 8usize, 8usize)?;
232 let m_tau = match m_tau {
233 _serde::__private::Some(__field) => __field,
234 _serde::__private::None => {
235 return _serde::__private::Err(
236 <__A::Error as _serde::de::Error>::missing_field("tau"),
237 );
238 }
239 };
240 let m_maxAcceleration = match m_maxAcceleration {
241 _serde::__private::Some(__field) => __field,
242 _serde::__private::None => {
243 return _serde::__private::Err(
244 <__A::Error as _serde::de::Error>::missing_field(
245 "maxAcceleration",
246 ),
247 );
248 }
249 };
250 _serde::__private::Ok(hkpSoftContactModifierConstraintAtom {
251 __ptr,
252 parent,
253 m_tau,
254 m_maxAcceleration,
255 })
256 }
257 #[allow(clippy::manual_unwrap_or_default)]
258 fn visit_struct<__A>(
259 self,
260 mut __map: __A,
261 ) -> _serde::__private::Result<Self::Value, __A::Error>
262 where
263 __A: _serde::de::MapAccess<'de>,
264 {
265 let mut m_type: _serde::__private::Option<AtomType> = _serde::__private::None;
266 let mut m_modifierAtomSize: _serde::__private::Option<u16> = _serde::__private::None;
267 let mut m_childSize: _serde::__private::Option<u16> = _serde::__private::None;
268 let mut m_child: _serde::__private::Option<Pointer> = _serde::__private::None;
269 let mut m_pad: _serde::__private::Option<[u32; 2usize]> = _serde::__private::None;
270 let mut m_tau: _serde::__private::Option<f32> = _serde::__private::None;
271 let mut m_maxAcceleration: _serde::__private::Option<f32> = _serde::__private::None;
272 while let _serde::__private::Some(__key) = {
273 __A::next_key::<__Field>(&mut __map)?
274 } {
275 match __key {
276 __Field::m_type => {
277 #[cfg(
278 any(feature = "strict", feature = "ignore_duplicates")
279 )]
280 if _serde::__private::Option::is_some(&m_type) {
281 #[cfg(feature = "ignore_duplicates")]
282 {
283 __A::skip_value(&mut __map)?;
284 continue;
285 }
286 #[cfg(feature = "strict")]
287 return _serde::__private::Err(
288 <__A::Error as _serde::de::Error>::duplicate_field("type"),
289 );
290 }
291 m_type = _serde::__private::Some(
292 match __A::next_value::<AtomType>(&mut __map) {
293 _serde::__private::Ok(__val) => __val,
294 _serde::__private::Err(__err) => {
295 return _serde::__private::Err(__err);
296 }
297 },
298 );
299 }
300 __Field::m_modifierAtomSize => {
301 #[cfg(
302 any(feature = "strict", feature = "ignore_duplicates")
303 )]
304 if _serde::__private::Option::is_some(&m_modifierAtomSize) {
305 #[cfg(feature = "ignore_duplicates")]
306 {
307 __A::skip_value(&mut __map)?;
308 continue;
309 }
310 #[cfg(feature = "strict")]
311 return _serde::__private::Err(
312 <__A::Error as _serde::de::Error>::duplicate_field(
313 "modifierAtomSize",
314 ),
315 );
316 }
317 m_modifierAtomSize = _serde::__private::Some(
318 match __A::next_value::<u16>(&mut __map) {
319 _serde::__private::Ok(__val) => __val,
320 _serde::__private::Err(__err) => {
321 return _serde::__private::Err(__err);
322 }
323 },
324 );
325 }
326 __Field::m_childSize => {
327 #[cfg(
328 any(feature = "strict", feature = "ignore_duplicates")
329 )]
330 if _serde::__private::Option::is_some(&m_childSize) {
331 #[cfg(feature = "ignore_duplicates")]
332 {
333 __A::skip_value(&mut __map)?;
334 continue;
335 }
336 #[cfg(feature = "strict")]
337 return _serde::__private::Err(
338 <__A::Error as _serde::de::Error>::duplicate_field(
339 "childSize",
340 ),
341 );
342 }
343 m_childSize = _serde::__private::Some(
344 match __A::next_value::<u16>(&mut __map) {
345 _serde::__private::Ok(__val) => __val,
346 _serde::__private::Err(__err) => {
347 return _serde::__private::Err(__err);
348 }
349 },
350 );
351 }
352 __Field::m_child => {
353 #[cfg(
354 any(feature = "strict", feature = "ignore_duplicates")
355 )]
356 if _serde::__private::Option::is_some(&m_child) {
357 #[cfg(feature = "ignore_duplicates")]
358 {
359 __A::skip_value(&mut __map)?;
360 continue;
361 }
362 #[cfg(feature = "strict")]
363 return _serde::__private::Err(
364 <__A::Error as _serde::de::Error>::duplicate_field("child"),
365 );
366 }
367 m_child = _serde::__private::Some(
368 match __A::next_value::<Pointer>(&mut __map) {
369 _serde::__private::Ok(__val) => __val,
370 _serde::__private::Err(__err) => {
371 return _serde::__private::Err(__err);
372 }
373 },
374 );
375 }
376 __Field::m_pad => {
377 #[cfg(
378 any(feature = "strict", feature = "ignore_duplicates")
379 )]
380 if _serde::__private::Option::is_some(&m_pad) {
381 #[cfg(feature = "ignore_duplicates")]
382 {
383 __A::skip_value(&mut __map)?;
384 continue;
385 }
386 #[cfg(feature = "strict")]
387 return _serde::__private::Err(
388 <__A::Error as _serde::de::Error>::duplicate_field("pad"),
389 );
390 }
391 m_pad = _serde::__private::Some(
392 match __A::next_value::<[u32; 2usize]>(&mut __map) {
393 _serde::__private::Ok(__val) => __val,
394 _serde::__private::Err(__err) => {
395 return _serde::__private::Err(__err);
396 }
397 },
398 );
399 }
400 __Field::m_tau => {
401 #[cfg(
402 any(feature = "strict", feature = "ignore_duplicates")
403 )]
404 if _serde::__private::Option::is_some(&m_tau) {
405 #[cfg(feature = "ignore_duplicates")]
406 {
407 __A::skip_value(&mut __map)?;
408 continue;
409 }
410 #[cfg(feature = "strict")]
411 return _serde::__private::Err(
412 <__A::Error as _serde::de::Error>::duplicate_field("tau"),
413 );
414 }
415 m_tau = _serde::__private::Some(
416 match __A::next_value::<f32>(&mut __map) {
417 _serde::__private::Ok(__val) => __val,
418 _serde::__private::Err(__err) => {
419 return _serde::__private::Err(__err);
420 }
421 },
422 );
423 }
424 __Field::m_maxAcceleration => {
425 #[cfg(
426 any(feature = "strict", feature = "ignore_duplicates")
427 )]
428 if _serde::__private::Option::is_some(&m_maxAcceleration) {
429 #[cfg(feature = "ignore_duplicates")]
430 {
431 __A::skip_value(&mut __map)?;
432 continue;
433 }
434 #[cfg(feature = "strict")]
435 return _serde::__private::Err(
436 <__A::Error as _serde::de::Error>::duplicate_field(
437 "maxAcceleration",
438 ),
439 );
440 }
441 m_maxAcceleration = _serde::__private::Some(
442 match __A::next_value::<f32>(&mut __map) {
443 _serde::__private::Ok(__val) => __val,
444 _serde::__private::Err(__err) => {
445 return _serde::__private::Err(__err);
446 }
447 },
448 );
449 }
450 _ => __A::skip_value(&mut __map)?,
451 }
452 }
453 let m_type = match m_type {
454 _serde::__private::Some(__field) => __field,
455 _serde::__private::None => {
456 #[cfg(feature = "strict")]
457 return _serde::__private::Err(
458 <__A::Error as _serde::de::Error>::missing_field("type"),
459 );
460 #[cfg(not(feature = "strict"))] Default::default()
461 }
462 };
463 let m_modifierAtomSize = match m_modifierAtomSize {
464 _serde::__private::Some(__field) => __field,
465 _serde::__private::None => {
466 #[cfg(feature = "strict")]
467 return _serde::__private::Err(
468 <__A::Error as _serde::de::Error>::missing_field(
469 "modifierAtomSize",
470 ),
471 );
472 #[cfg(not(feature = "strict"))] Default::default()
473 }
474 };
475 let m_childSize = match m_childSize {
476 _serde::__private::Some(__field) => __field,
477 _serde::__private::None => {
478 #[cfg(feature = "strict")]
479 return _serde::__private::Err(
480 <__A::Error as _serde::de::Error>::missing_field(
481 "childSize",
482 ),
483 );
484 #[cfg(not(feature = "strict"))] Default::default()
485 }
486 };
487 let m_child = match m_child {
488 _serde::__private::Some(__field) => __field,
489 _serde::__private::None => {
490 #[cfg(feature = "strict")]
491 return _serde::__private::Err(
492 <__A::Error as _serde::de::Error>::missing_field("child"),
493 );
494 #[cfg(not(feature = "strict"))] Default::default()
495 }
496 };
497 let m_pad = match m_pad {
498 _serde::__private::Some(__field) => __field,
499 _serde::__private::None => {
500 #[cfg(feature = "strict")]
501 return _serde::__private::Err(
502 <__A::Error as _serde::de::Error>::missing_field("pad"),
503 );
504 #[cfg(not(feature = "strict"))] Default::default()
505 }
506 };
507 let m_tau = match m_tau {
508 _serde::__private::Some(__field) => __field,
509 _serde::__private::None => {
510 #[cfg(feature = "strict")]
511 return _serde::__private::Err(
512 <__A::Error as _serde::de::Error>::missing_field("tau"),
513 );
514 #[cfg(not(feature = "strict"))] Default::default()
515 }
516 };
517 let m_maxAcceleration = match m_maxAcceleration {
518 _serde::__private::Some(__field) => __field,
519 _serde::__private::None => {
520 #[cfg(feature = "strict")]
521 return _serde::__private::Err(
522 <__A::Error as _serde::de::Error>::missing_field(
523 "maxAcceleration",
524 ),
525 );
526 #[cfg(not(feature = "strict"))] Default::default()
527 }
528 };
529 let __ptr = None;
530 let parent = hkpConstraintAtom { __ptr, m_type };
531 let parent = hkpModifierConstraintAtom {
532 __ptr,
533 parent,
534 m_modifierAtomSize,
535 m_childSize,
536 m_child,
537 m_pad,
538 };
539 let __ptr = __A::class_ptr(&mut __map);
540 _serde::__private::Ok(hkpSoftContactModifierConstraintAtom {
541 __ptr,
542 parent,
543 m_tau,
544 m_maxAcceleration,
545 })
546 }
547 }
548 const FIELDS: &[&str] = &["tau", "maxAcceleration"];
549 _serde::Deserializer::deserialize_struct(
550 deserializer,
551 "hkpSoftContactModifierConstraintAtom",
552 FIELDS,
553 __hkpSoftContactModifierConstraintAtomVisitor {
554 marker: _serde::__private::PhantomData::<
555 hkpSoftContactModifierConstraintAtom,
556 >,
557 lifetime: _serde::__private::PhantomData,
558 },
559 )
560 }
561 }
562};