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