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