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 hkpAngLimitConstraintAtom {
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: hkpConstraintAtom,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "isEnabled"))]
35 #[cfg_attr(feature = "serde", serde(rename = "isEnabled"))]
36 pub m_isEnabled: u8,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "limitAxis"))]
42 #[cfg_attr(feature = "serde", serde(rename = "limitAxis"))]
43 pub m_limitAxis: u8,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "minAngle"))]
49 #[cfg_attr(feature = "serde", serde(rename = "minAngle"))]
50 pub m_minAngle: f32,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "maxAngle"))]
56 #[cfg_attr(feature = "serde", serde(rename = "maxAngle"))]
57 pub m_maxAngle: f32,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "angularLimitsTauFactor"))]
63 #[cfg_attr(feature = "serde", serde(rename = "angularLimitsTauFactor"))]
64 pub m_angularLimitsTauFactor: f32,
65}
66const _: () = {
67 use havok_serde as _serde;
68 impl _serde::HavokClass for hkpAngLimitConstraintAtom {
69 #[inline]
70 fn name(&self) -> &'static str {
71 "hkpAngLimitConstraintAtom"
72 }
73 #[inline]
74 fn signature(&self) -> _serde::__private::Signature {
75 _serde::__private::Signature::new(0x9be0d9d)
76 }
77 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
78 fn deps_indexes(&self) -> Vec<usize> {
79 let mut v = Vec::new();
80 v
81 }
82 }
83 impl _serde::Serialize for hkpAngLimitConstraintAtom {
84 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
85 where
86 S: _serde::ser::Serializer,
87 {
88 let class_meta = self
89 .__ptr
90 .map(|name| (name, _serde::__private::Signature::new(0x9be0d9d)));
91 let mut serializer = __serializer
92 .serialize_struct(
93 "hkpAngLimitConstraintAtom",
94 class_meta,
95 (16u64, 16u64),
96 )?;
97 serializer.serialize_field("type", &self.parent.m_type)?;
98 serializer.serialize_field("isEnabled", &self.m_isEnabled)?;
99 serializer.serialize_field("limitAxis", &self.m_limitAxis)?;
100 serializer.serialize_field("minAngle", &self.m_minAngle)?;
101 serializer.serialize_field("maxAngle", &self.m_maxAngle)?;
102 serializer
103 .serialize_field(
104 "angularLimitsTauFactor",
105 &self.m_angularLimitsTauFactor,
106 )?;
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 hkpAngLimitConstraintAtom {
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_type,
124 m_isEnabled,
125 m_limitAxis,
126 m_minAngle,
127 m_maxAngle,
128 m_angularLimitsTauFactor,
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 "type" => Ok(__Field::m_type),
153 "isEnabled" => Ok(__Field::m_isEnabled),
154 "limitAxis" => Ok(__Field::m_limitAxis),
155 "minAngle" => Ok(__Field::m_minAngle),
156 "maxAngle" => Ok(__Field::m_maxAngle),
157 "angularLimitsTauFactor" => Ok(__Field::m_angularLimitsTauFactor),
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 __hkpAngLimitConstraintAtomVisitor<'de> {
174 marker: _serde::__private::PhantomData<hkpAngLimitConstraintAtom>,
175 lifetime: _serde::__private::PhantomData<&'de ()>,
176 }
177 #[allow(clippy::match_single_binding)]
178 #[allow(clippy::reversed_empty_ranges)]
179 #[allow(clippy::single_match)]
180 impl<'de> _serde::de::Visitor<'de>
181 for __hkpAngLimitConstraintAtomVisitor<'de> {
182 type Value = hkpAngLimitConstraintAtom;
183 fn expecting(
184 &self,
185 __formatter: &mut core::fmt::Formatter,
186 ) -> core::fmt::Result {
187 core::fmt::Formatter::write_str(
188 __formatter,
189 "struct hkpAngLimitConstraintAtom",
190 )
191 }
192 fn visit_struct_for_bytes<__A>(
193 self,
194 mut __map: __A,
195 ) -> _serde::__private::Result<Self::Value, __A::Error>
196 where
197 __A: _serde::de::MapAccess<'de>,
198 {
199 let __ptr = __A::class_ptr(&mut __map);
200 let parent = __A::parent_value(&mut __map)?;
201 let mut m_isEnabled: _serde::__private::Option<u8> = _serde::__private::None;
202 let mut m_limitAxis: _serde::__private::Option<u8> = _serde::__private::None;
203 let mut m_minAngle: _serde::__private::Option<f32> = _serde::__private::None;
204 let mut m_maxAngle: _serde::__private::Option<f32> = _serde::__private::None;
205 let mut m_angularLimitsTauFactor: _serde::__private::Option<f32> = _serde::__private::None;
206 for i in 0..5usize {
207 match i {
208 0usize => {
209 if _serde::__private::Option::is_some(&m_isEnabled) {
210 return _serde::__private::Err(
211 <__A::Error as _serde::de::Error>::duplicate_field(
212 "isEnabled",
213 ),
214 );
215 }
216 m_isEnabled = _serde::__private::Some(
217 match __A::next_value::<u8>(&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_limitAxis) {
227 return _serde::__private::Err(
228 <__A::Error as _serde::de::Error>::duplicate_field(
229 "limitAxis",
230 ),
231 );
232 }
233 m_limitAxis = _serde::__private::Some(
234 match __A::next_value::<u8>(&mut __map) {
235 _serde::__private::Ok(__val) => __val,
236 _serde::__private::Err(__err) => {
237 return _serde::__private::Err(__err);
238 }
239 },
240 );
241 }
242 2usize => {
243 if _serde::__private::Option::is_some(&m_minAngle) {
244 return _serde::__private::Err(
245 <__A::Error as _serde::de::Error>::duplicate_field(
246 "minAngle",
247 ),
248 );
249 }
250 m_minAngle = _serde::__private::Some(
251 match __A::next_value::<f32>(&mut __map) {
252 _serde::__private::Ok(__val) => __val,
253 _serde::__private::Err(__err) => {
254 return _serde::__private::Err(__err);
255 }
256 },
257 );
258 }
259 3usize => {
260 if _serde::__private::Option::is_some(&m_maxAngle) {
261 return _serde::__private::Err(
262 <__A::Error as _serde::de::Error>::duplicate_field(
263 "maxAngle",
264 ),
265 );
266 }
267 m_maxAngle = _serde::__private::Some(
268 match __A::next_value::<f32>(&mut __map) {
269 _serde::__private::Ok(__val) => __val,
270 _serde::__private::Err(__err) => {
271 return _serde::__private::Err(__err);
272 }
273 },
274 );
275 }
276 4usize => {
277 if _serde::__private::Option::is_some(
278 &m_angularLimitsTauFactor,
279 ) {
280 return _serde::__private::Err(
281 <__A::Error as _serde::de::Error>::duplicate_field(
282 "angularLimitsTauFactor",
283 ),
284 );
285 }
286 m_angularLimitsTauFactor = _serde::__private::Some(
287 match __A::next_value::<f32>(&mut __map) {
288 _serde::__private::Ok(__val) => __val,
289 _serde::__private::Err(__err) => {
290 return _serde::__private::Err(__err);
291 }
292 },
293 );
294 }
295 _ => {}
296 }
297 }
298 let m_isEnabled = match m_isEnabled {
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 "isEnabled",
304 ),
305 );
306 }
307 };
308 let m_limitAxis = match m_limitAxis {
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 "limitAxis",
314 ),
315 );
316 }
317 };
318 let m_minAngle = match m_minAngle {
319 _serde::__private::Some(__field) => __field,
320 _serde::__private::None => {
321 return _serde::__private::Err(
322 <__A::Error as _serde::de::Error>::missing_field("minAngle"),
323 );
324 }
325 };
326 let m_maxAngle = match m_maxAngle {
327 _serde::__private::Some(__field) => __field,
328 _serde::__private::None => {
329 return _serde::__private::Err(
330 <__A::Error as _serde::de::Error>::missing_field("maxAngle"),
331 );
332 }
333 };
334 let m_angularLimitsTauFactor = match m_angularLimitsTauFactor {
335 _serde::__private::Some(__field) => __field,
336 _serde::__private::None => {
337 return _serde::__private::Err(
338 <__A::Error as _serde::de::Error>::missing_field(
339 "angularLimitsTauFactor",
340 ),
341 );
342 }
343 };
344 _serde::__private::Ok(hkpAngLimitConstraintAtom {
345 __ptr,
346 parent,
347 m_isEnabled,
348 m_limitAxis,
349 m_minAngle,
350 m_maxAngle,
351 m_angularLimitsTauFactor,
352 })
353 }
354 #[allow(clippy::manual_unwrap_or_default)]
355 fn visit_struct<__A>(
356 self,
357 mut __map: __A,
358 ) -> _serde::__private::Result<Self::Value, __A::Error>
359 where
360 __A: _serde::de::MapAccess<'de>,
361 {
362 let mut m_type: _serde::__private::Option<AtomType> = _serde::__private::None;
363 let mut m_isEnabled: _serde::__private::Option<u8> = _serde::__private::None;
364 let mut m_limitAxis: _serde::__private::Option<u8> = _serde::__private::None;
365 let mut m_minAngle: _serde::__private::Option<f32> = _serde::__private::None;
366 let mut m_maxAngle: _serde::__private::Option<f32> = _serde::__private::None;
367 let mut m_angularLimitsTauFactor: _serde::__private::Option<f32> = _serde::__private::None;
368 while let _serde::__private::Some(__key) = {
369 __A::next_key::<__Field>(&mut __map)?
370 } {
371 match __key {
372 __Field::m_type => {
373 #[cfg(
374 any(feature = "strict", feature = "ignore_duplicates")
375 )]
376 if _serde::__private::Option::is_some(&m_type) {
377 #[cfg(feature = "ignore_duplicates")]
378 {
379 __A::skip_value(&mut __map)?;
380 continue;
381 }
382 #[cfg(feature = "strict")]
383 return _serde::__private::Err(
384 <__A::Error as _serde::de::Error>::duplicate_field("type"),
385 );
386 }
387 m_type = _serde::__private::Some(
388 match __A::next_value::<AtomType>(&mut __map) {
389 _serde::__private::Ok(__val) => __val,
390 _serde::__private::Err(__err) => {
391 return _serde::__private::Err(__err);
392 }
393 },
394 );
395 }
396 __Field::m_isEnabled => {
397 #[cfg(
398 any(feature = "strict", feature = "ignore_duplicates")
399 )]
400 if _serde::__private::Option::is_some(&m_isEnabled) {
401 #[cfg(feature = "ignore_duplicates")]
402 {
403 __A::skip_value(&mut __map)?;
404 continue;
405 }
406 #[cfg(feature = "strict")]
407 return _serde::__private::Err(
408 <__A::Error as _serde::de::Error>::duplicate_field(
409 "isEnabled",
410 ),
411 );
412 }
413 m_isEnabled = _serde::__private::Some(
414 match __A::next_value::<u8>(&mut __map) {
415 _serde::__private::Ok(__val) => __val,
416 _serde::__private::Err(__err) => {
417 return _serde::__private::Err(__err);
418 }
419 },
420 );
421 }
422 __Field::m_limitAxis => {
423 #[cfg(
424 any(feature = "strict", feature = "ignore_duplicates")
425 )]
426 if _serde::__private::Option::is_some(&m_limitAxis) {
427 #[cfg(feature = "ignore_duplicates")]
428 {
429 __A::skip_value(&mut __map)?;
430 continue;
431 }
432 #[cfg(feature = "strict")]
433 return _serde::__private::Err(
434 <__A::Error as _serde::de::Error>::duplicate_field(
435 "limitAxis",
436 ),
437 );
438 }
439 m_limitAxis = _serde::__private::Some(
440 match __A::next_value::<u8>(&mut __map) {
441 _serde::__private::Ok(__val) => __val,
442 _serde::__private::Err(__err) => {
443 return _serde::__private::Err(__err);
444 }
445 },
446 );
447 }
448 __Field::m_minAngle => {
449 #[cfg(
450 any(feature = "strict", feature = "ignore_duplicates")
451 )]
452 if _serde::__private::Option::is_some(&m_minAngle) {
453 #[cfg(feature = "ignore_duplicates")]
454 {
455 __A::skip_value(&mut __map)?;
456 continue;
457 }
458 #[cfg(feature = "strict")]
459 return _serde::__private::Err(
460 <__A::Error as _serde::de::Error>::duplicate_field(
461 "minAngle",
462 ),
463 );
464 }
465 m_minAngle = _serde::__private::Some(
466 match __A::next_value::<f32>(&mut __map) {
467 _serde::__private::Ok(__val) => __val,
468 _serde::__private::Err(__err) => {
469 return _serde::__private::Err(__err);
470 }
471 },
472 );
473 }
474 __Field::m_maxAngle => {
475 #[cfg(
476 any(feature = "strict", feature = "ignore_duplicates")
477 )]
478 if _serde::__private::Option::is_some(&m_maxAngle) {
479 #[cfg(feature = "ignore_duplicates")]
480 {
481 __A::skip_value(&mut __map)?;
482 continue;
483 }
484 #[cfg(feature = "strict")]
485 return _serde::__private::Err(
486 <__A::Error as _serde::de::Error>::duplicate_field(
487 "maxAngle",
488 ),
489 );
490 }
491 m_maxAngle = _serde::__private::Some(
492 match __A::next_value::<f32>(&mut __map) {
493 _serde::__private::Ok(__val) => __val,
494 _serde::__private::Err(__err) => {
495 return _serde::__private::Err(__err);
496 }
497 },
498 );
499 }
500 __Field::m_angularLimitsTauFactor => {
501 #[cfg(
502 any(feature = "strict", feature = "ignore_duplicates")
503 )]
504 if _serde::__private::Option::is_some(
505 &m_angularLimitsTauFactor,
506 ) {
507 #[cfg(feature = "ignore_duplicates")]
508 {
509 __A::skip_value(&mut __map)?;
510 continue;
511 }
512 #[cfg(feature = "strict")]
513 return _serde::__private::Err(
514 <__A::Error as _serde::de::Error>::duplicate_field(
515 "angularLimitsTauFactor",
516 ),
517 );
518 }
519 m_angularLimitsTauFactor = _serde::__private::Some(
520 match __A::next_value::<f32>(&mut __map) {
521 _serde::__private::Ok(__val) => __val,
522 _serde::__private::Err(__err) => {
523 return _serde::__private::Err(__err);
524 }
525 },
526 );
527 }
528 _ => __A::skip_value(&mut __map)?,
529 }
530 }
531 let m_type = match m_type {
532 _serde::__private::Some(__field) => __field,
533 _serde::__private::None => {
534 #[cfg(feature = "strict")]
535 return _serde::__private::Err(
536 <__A::Error as _serde::de::Error>::missing_field("type"),
537 );
538 #[cfg(not(feature = "strict"))] Default::default()
539 }
540 };
541 let m_isEnabled = match m_isEnabled {
542 _serde::__private::Some(__field) => __field,
543 _serde::__private::None => {
544 #[cfg(feature = "strict")]
545 return _serde::__private::Err(
546 <__A::Error as _serde::de::Error>::missing_field(
547 "isEnabled",
548 ),
549 );
550 #[cfg(not(feature = "strict"))] Default::default()
551 }
552 };
553 let m_limitAxis = match m_limitAxis {
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(
559 "limitAxis",
560 ),
561 );
562 #[cfg(not(feature = "strict"))] Default::default()
563 }
564 };
565 let m_minAngle = match m_minAngle {
566 _serde::__private::Some(__field) => __field,
567 _serde::__private::None => {
568 #[cfg(feature = "strict")]
569 return _serde::__private::Err(
570 <__A::Error as _serde::de::Error>::missing_field("minAngle"),
571 );
572 #[cfg(not(feature = "strict"))] Default::default()
573 }
574 };
575 let m_maxAngle = match m_maxAngle {
576 _serde::__private::Some(__field) => __field,
577 _serde::__private::None => {
578 #[cfg(feature = "strict")]
579 return _serde::__private::Err(
580 <__A::Error as _serde::de::Error>::missing_field("maxAngle"),
581 );
582 #[cfg(not(feature = "strict"))] Default::default()
583 }
584 };
585 let m_angularLimitsTauFactor = match m_angularLimitsTauFactor {
586 _serde::__private::Some(__field) => __field,
587 _serde::__private::None => {
588 #[cfg(feature = "strict")]
589 return _serde::__private::Err(
590 <__A::Error as _serde::de::Error>::missing_field(
591 "angularLimitsTauFactor",
592 ),
593 );
594 #[cfg(not(feature = "strict"))] Default::default()
595 }
596 };
597 let __ptr = None;
598 let parent = hkpConstraintAtom { __ptr, m_type };
599 let __ptr = __A::class_ptr(&mut __map);
600 _serde::__private::Ok(hkpAngLimitConstraintAtom {
601 __ptr,
602 parent,
603 m_isEnabled,
604 m_limitAxis,
605 m_minAngle,
606 m_maxAngle,
607 m_angularLimitsTauFactor,
608 })
609 }
610 }
611 const FIELDS: &[&str] = &[
612 "isEnabled",
613 "limitAxis",
614 "minAngle",
615 "maxAngle",
616 "angularLimitsTauFactor",
617 ];
618 _serde::Deserializer::deserialize_struct(
619 deserializer,
620 "hkpAngLimitConstraintAtom",
621 FIELDS,
622 __hkpAngLimitConstraintAtomVisitor {
623 marker: _serde::__private::PhantomData::<hkpAngLimitConstraintAtom>,
624 lifetime: _serde::__private::PhantomData,
625 },
626 )
627 }
628 }
629};