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