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