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 hkpHingeLimitsDataAtoms {
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 = "angLimit"))]
38 #[cfg_attr(feature = "serde", serde(rename = "angLimit"))]
39 pub m_angLimit: hkpAngLimitConstraintAtom,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "2dAng"))]
45 #[cfg_attr(feature = "serde", serde(rename = "2dAng"))]
46 pub m_2dAng: hkp2dAngConstraintAtom,
47}
48const _: () = {
49 use havok_serde as _serde;
50 impl _serde::HavokClass for hkpHingeLimitsDataAtoms {
51 #[inline]
52 fn name(&self) -> &'static str {
53 "hkpHingeLimitsDataAtoms"
54 }
55 #[inline]
56 fn signature(&self) -> _serde::__private::Signature {
57 _serde::__private::Signature::new(0x555876ff)
58 }
59 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
60 fn deps_indexes(&self) -> Vec<usize> {
61 let mut v = Vec::new();
62 v.extend(self.m_rotations.deps_indexes());
63 v.extend(self.m_angLimit.deps_indexes());
64 v.extend(self.m_2dAng.deps_indexes());
65 v
66 }
67 }
68 impl _serde::Serialize for hkpHingeLimitsDataAtoms {
69 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
70 where
71 S: _serde::ser::Serializer,
72 {
73 let class_meta = self
74 .__ptr
75 .map(|name| (name, _serde::__private::Signature::new(0x555876ff)));
76 let mut serializer = __serializer
77 .serialize_struct(
78 "hkpHingeLimitsDataAtoms",
79 class_meta,
80 (144u64, 144u64),
81 )?;
82 serializer.serialize_field("rotations", &self.m_rotations)?;
83 serializer.serialize_field("angLimit", &self.m_angLimit)?;
84 serializer.serialize_field("2dAng", &self.m_2dAng)?;
85 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 12usize].as_slice())?;
86 serializer.end()
87 }
88 }
89};
90#[doc(hidden)]
91#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
92const _: () = {
93 use havok_serde as _serde;
94 #[automatically_derived]
95 impl<'de> _serde::Deserialize<'de> for hkpHingeLimitsDataAtoms {
96 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
97 where
98 __D: _serde::Deserializer<'de>,
99 {
100 #[allow(non_camel_case_types)]
101 enum __Field {
102 m_rotations,
103 m_angLimit,
104 m_2dAng,
105 __ignore,
106 }
107 struct __FieldVisitor;
108 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
109 type Value = __Field;
110 fn expecting(
111 &self,
112 __formatter: &mut core::fmt::Formatter,
113 ) -> core::fmt::Result {
114 core::fmt::Formatter::write_str(__formatter, "field identifier")
115 }
116 #[allow(clippy::match_single_binding)]
118 #[allow(clippy::reversed_empty_ranges)]
119 #[allow(clippy::single_match)]
120 fn visit_key<__E>(
121 self,
122 __value: &str,
123 ) -> core::result::Result<Self::Value, __E>
124 where
125 __E: _serde::de::Error,
126 {
127 match __value {
128 "rotations" => Ok(__Field::m_rotations),
129 "angLimit" => Ok(__Field::m_angLimit),
130 "2dAng" => Ok(__Field::m_2dAng),
131 _ => Ok(__Field::__ignore),
132 }
133 }
134 }
135 impl<'de> _serde::Deserialize<'de> for __Field {
136 #[inline]
137 fn deserialize<__D>(
138 __deserializer: __D,
139 ) -> core::result::Result<Self, __D::Error>
140 where
141 __D: _serde::Deserializer<'de>,
142 {
143 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
144 }
145 }
146 struct __hkpHingeLimitsDataAtomsVisitor<'de> {
147 marker: _serde::__private::PhantomData<hkpHingeLimitsDataAtoms>,
148 lifetime: _serde::__private::PhantomData<&'de ()>,
149 }
150 #[allow(clippy::match_single_binding)]
151 #[allow(clippy::reversed_empty_ranges)]
152 #[allow(clippy::single_match)]
153 impl<'de> _serde::de::Visitor<'de>
154 for __hkpHingeLimitsDataAtomsVisitor<'de> {
155 type Value = hkpHingeLimitsDataAtoms;
156 fn expecting(
157 &self,
158 __formatter: &mut core::fmt::Formatter,
159 ) -> core::fmt::Result {
160 core::fmt::Formatter::write_str(
161 __formatter,
162 "struct hkpHingeLimitsDataAtoms",
163 )
164 }
165 fn visit_struct_for_bytes<__A>(
166 self,
167 mut __map: __A,
168 ) -> _serde::__private::Result<Self::Value, __A::Error>
169 where
170 __A: _serde::de::MapAccess<'de>,
171 {
172 let __ptr = __A::class_ptr(&mut __map);
173 let mut m_rotations: _serde::__private::Option<
174 hkpSetLocalRotationsConstraintAtom,
175 > = _serde::__private::None;
176 let mut m_angLimit: _serde::__private::Option<
177 hkpAngLimitConstraintAtom,
178 > = _serde::__private::None;
179 let mut m_2dAng: _serde::__private::Option<hkp2dAngConstraintAtom> = _serde::__private::None;
180 for i in 0..3usize {
181 match i {
182 0usize => {
183 if _serde::__private::Option::is_some(&m_rotations) {
184 return _serde::__private::Err(
185 <__A::Error as _serde::de::Error>::duplicate_field(
186 "rotations",
187 ),
188 );
189 }
190 m_rotations = _serde::__private::Some(
191 match __A::next_value::<
192 hkpSetLocalRotationsConstraintAtom,
193 >(&mut __map) {
194 _serde::__private::Ok(__val) => __val,
195 _serde::__private::Err(__err) => {
196 return _serde::__private::Err(__err);
197 }
198 },
199 );
200 }
201 1usize => {
202 if _serde::__private::Option::is_some(&m_angLimit) {
203 return _serde::__private::Err(
204 <__A::Error as _serde::de::Error>::duplicate_field(
205 "angLimit",
206 ),
207 );
208 }
209 m_angLimit = _serde::__private::Some(
210 match __A::next_value::<
211 hkpAngLimitConstraintAtom,
212 >(&mut __map) {
213 _serde::__private::Ok(__val) => __val,
214 _serde::__private::Err(__err) => {
215 return _serde::__private::Err(__err);
216 }
217 },
218 );
219 }
220 2usize => {
221 if _serde::__private::Option::is_some(&m_2dAng) {
222 return _serde::__private::Err(
223 <__A::Error as _serde::de::Error>::duplicate_field("2dAng"),
224 );
225 }
226 m_2dAng = _serde::__private::Some(
227 match __A::next_value::<
228 hkp2dAngConstraintAtom,
229 >(&mut __map) {
230 _serde::__private::Ok(__val) => __val,
231 _serde::__private::Err(__err) => {
232 return _serde::__private::Err(__err);
233 }
234 },
235 );
236 }
237 _ => {}
238 }
239 }
240 __A::pad(&mut __map, 12usize, 12usize)?;
241 let m_rotations = match m_rotations {
242 _serde::__private::Some(__field) => __field,
243 _serde::__private::None => {
244 return _serde::__private::Err(
245 <__A::Error as _serde::de::Error>::missing_field(
246 "rotations",
247 ),
248 );
249 }
250 };
251 let m_angLimit = match m_angLimit {
252 _serde::__private::Some(__field) => __field,
253 _serde::__private::None => {
254 return _serde::__private::Err(
255 <__A::Error as _serde::de::Error>::missing_field("angLimit"),
256 );
257 }
258 };
259 let m_2dAng = match m_2dAng {
260 _serde::__private::Some(__field) => __field,
261 _serde::__private::None => {
262 return _serde::__private::Err(
263 <__A::Error as _serde::de::Error>::missing_field("2dAng"),
264 );
265 }
266 };
267 _serde::__private::Ok(hkpHingeLimitsDataAtoms {
268 __ptr,
269 m_rotations,
270 m_angLimit,
271 m_2dAng,
272 })
273 }
274 #[allow(clippy::manual_unwrap_or_default)]
275 fn visit_struct<__A>(
276 self,
277 mut __map: __A,
278 ) -> _serde::__private::Result<Self::Value, __A::Error>
279 where
280 __A: _serde::de::MapAccess<'de>,
281 {
282 let mut m_rotations: _serde::__private::Option<
283 hkpSetLocalRotationsConstraintAtom,
284 > = _serde::__private::None;
285 let mut m_angLimit: _serde::__private::Option<
286 hkpAngLimitConstraintAtom,
287 > = _serde::__private::None;
288 let mut m_2dAng: _serde::__private::Option<hkp2dAngConstraintAtom> = _serde::__private::None;
289 while let _serde::__private::Some(__key) = {
290 __A::next_key::<__Field>(&mut __map)?
291 } {
292 match __key {
293 __Field::m_rotations => {
294 #[cfg(
295 any(feature = "strict", feature = "ignore_duplicates")
296 )]
297 if _serde::__private::Option::is_some(&m_rotations) {
298 #[cfg(feature = "ignore_duplicates")]
299 {
300 __A::skip_value(&mut __map)?;
301 continue;
302 }
303 #[cfg(feature = "strict")]
304 return _serde::__private::Err(
305 <__A::Error as _serde::de::Error>::duplicate_field(
306 "rotations",
307 ),
308 );
309 }
310 m_rotations = _serde::__private::Some(
311 match __A::next_value::<
312 hkpSetLocalRotationsConstraintAtom,
313 >(&mut __map) {
314 _serde::__private::Ok(__val) => __val,
315 _serde::__private::Err(__err) => {
316 return _serde::__private::Err(__err);
317 }
318 },
319 );
320 }
321 __Field::m_angLimit => {
322 #[cfg(
323 any(feature = "strict", feature = "ignore_duplicates")
324 )]
325 if _serde::__private::Option::is_some(&m_angLimit) {
326 #[cfg(feature = "ignore_duplicates")]
327 {
328 __A::skip_value(&mut __map)?;
329 continue;
330 }
331 #[cfg(feature = "strict")]
332 return _serde::__private::Err(
333 <__A::Error as _serde::de::Error>::duplicate_field(
334 "angLimit",
335 ),
336 );
337 }
338 m_angLimit = _serde::__private::Some(
339 match __A::next_value::<
340 hkpAngLimitConstraintAtom,
341 >(&mut __map) {
342 _serde::__private::Ok(__val) => __val,
343 _serde::__private::Err(__err) => {
344 return _serde::__private::Err(__err);
345 }
346 },
347 );
348 }
349 __Field::m_2dAng => {
350 #[cfg(
351 any(feature = "strict", feature = "ignore_duplicates")
352 )]
353 if _serde::__private::Option::is_some(&m_2dAng) {
354 #[cfg(feature = "ignore_duplicates")]
355 {
356 __A::skip_value(&mut __map)?;
357 continue;
358 }
359 #[cfg(feature = "strict")]
360 return _serde::__private::Err(
361 <__A::Error as _serde::de::Error>::duplicate_field("2dAng"),
362 );
363 }
364 m_2dAng = _serde::__private::Some(
365 match __A::next_value::<
366 hkp2dAngConstraintAtom,
367 >(&mut __map) {
368 _serde::__private::Ok(__val) => __val,
369 _serde::__private::Err(__err) => {
370 return _serde::__private::Err(__err);
371 }
372 },
373 );
374 }
375 _ => __A::skip_value(&mut __map)?,
376 }
377 }
378 let m_rotations = match m_rotations {
379 _serde::__private::Some(__field) => __field,
380 _serde::__private::None => {
381 #[cfg(feature = "strict")]
382 return _serde::__private::Err(
383 <__A::Error as _serde::de::Error>::missing_field(
384 "rotations",
385 ),
386 );
387 #[cfg(not(feature = "strict"))] Default::default()
388 }
389 };
390 let m_angLimit = match m_angLimit {
391 _serde::__private::Some(__field) => __field,
392 _serde::__private::None => {
393 #[cfg(feature = "strict")]
394 return _serde::__private::Err(
395 <__A::Error as _serde::de::Error>::missing_field("angLimit"),
396 );
397 #[cfg(not(feature = "strict"))] Default::default()
398 }
399 };
400 let m_2dAng = match m_2dAng {
401 _serde::__private::Some(__field) => __field,
402 _serde::__private::None => {
403 #[cfg(feature = "strict")]
404 return _serde::__private::Err(
405 <__A::Error as _serde::de::Error>::missing_field("2dAng"),
406 );
407 #[cfg(not(feature = "strict"))] Default::default()
408 }
409 };
410 let __ptr = __A::class_ptr(&mut __map);
411 _serde::__private::Ok(hkpHingeLimitsDataAtoms {
412 __ptr,
413 m_rotations,
414 m_angLimit,
415 m_2dAng,
416 })
417 }
418 }
419 const FIELDS: &[&str] = &["rotations", "angLimit", "2dAng"];
420 _serde::Deserializer::deserialize_struct(
421 deserializer,
422 "hkpHingeLimitsDataAtoms",
423 FIELDS,
424 __hkpHingeLimitsDataAtomsVisitor {
425 marker: _serde::__private::PhantomData::<hkpHingeLimitsDataAtoms>,
426 lifetime: _serde::__private::PhantomData,
427 },
428 )
429 }
430 }
431};