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 hkpAngFrictionConstraintAtom {
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 = "firstFrictionAxis"))]
42 #[cfg_attr(feature = "serde", serde(rename = "firstFrictionAxis"))]
43 pub m_firstFrictionAxis: u8,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "numFrictionAxes"))]
49 #[cfg_attr(feature = "serde", serde(rename = "numFrictionAxes"))]
50 pub m_numFrictionAxes: u8,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "maxFrictionTorque"))]
56 #[cfg_attr(feature = "serde", serde(rename = "maxFrictionTorque"))]
57 pub m_maxFrictionTorque: f32,
58}
59const _: () = {
60 use havok_serde as _serde;
61 impl _serde::HavokClass for hkpAngFrictionConstraintAtom {
62 #[inline]
63 fn name(&self) -> &'static str {
64 "hkpAngFrictionConstraintAtom"
65 }
66 #[inline]
67 fn signature(&self) -> _serde::__private::Signature {
68 _serde::__private::Signature::new(0xf313aa80)
69 }
70 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
71 fn deps_indexes(&self) -> Vec<usize> {
72 let mut v = Vec::new();
73 v
74 }
75 }
76 impl _serde::Serialize for hkpAngFrictionConstraintAtom {
77 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
78 where
79 S: _serde::ser::Serializer,
80 {
81 let class_meta = self
82 .__ptr
83 .map(|name| (name, _serde::__private::Signature::new(0xf313aa80)));
84 let mut serializer = __serializer
85 .serialize_struct(
86 "hkpAngFrictionConstraintAtom",
87 class_meta,
88 (12u64, 12u64),
89 )?;
90 serializer.serialize_field("type", &self.parent.m_type)?;
91 serializer.serialize_field("isEnabled", &self.m_isEnabled)?;
92 serializer.serialize_field("firstFrictionAxis", &self.m_firstFrictionAxis)?;
93 serializer.serialize_field("numFrictionAxes", &self.m_numFrictionAxes)?;
94 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
95 serializer.serialize_field("maxFrictionTorque", &self.m_maxFrictionTorque)?;
96 serializer.end()
97 }
98 }
99};
100#[doc(hidden)]
101#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
102const _: () = {
103 use havok_serde as _serde;
104 #[automatically_derived]
105 impl<'de> _serde::Deserialize<'de> for hkpAngFrictionConstraintAtom {
106 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
107 where
108 __D: _serde::Deserializer<'de>,
109 {
110 #[allow(non_camel_case_types)]
111 enum __Field {
112 m_type,
113 m_isEnabled,
114 m_firstFrictionAxis,
115 m_numFrictionAxes,
116 m_maxFrictionTorque,
117 __ignore,
118 }
119 struct __FieldVisitor;
120 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
121 type Value = __Field;
122 fn expecting(
123 &self,
124 __formatter: &mut core::fmt::Formatter,
125 ) -> core::fmt::Result {
126 core::fmt::Formatter::write_str(__formatter, "field identifier")
127 }
128 #[allow(clippy::match_single_binding)]
130 #[allow(clippy::reversed_empty_ranges)]
131 #[allow(clippy::single_match)]
132 fn visit_key<__E>(
133 self,
134 __value: &str,
135 ) -> core::result::Result<Self::Value, __E>
136 where
137 __E: _serde::de::Error,
138 {
139 match __value {
140 "type" => Ok(__Field::m_type),
141 "isEnabled" => Ok(__Field::m_isEnabled),
142 "firstFrictionAxis" => Ok(__Field::m_firstFrictionAxis),
143 "numFrictionAxes" => Ok(__Field::m_numFrictionAxes),
144 "maxFrictionTorque" => Ok(__Field::m_maxFrictionTorque),
145 _ => Ok(__Field::__ignore),
146 }
147 }
148 }
149 impl<'de> _serde::Deserialize<'de> for __Field {
150 #[inline]
151 fn deserialize<__D>(
152 __deserializer: __D,
153 ) -> core::result::Result<Self, __D::Error>
154 where
155 __D: _serde::Deserializer<'de>,
156 {
157 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
158 }
159 }
160 struct __hkpAngFrictionConstraintAtomVisitor<'de> {
161 marker: _serde::__private::PhantomData<hkpAngFrictionConstraintAtom>,
162 lifetime: _serde::__private::PhantomData<&'de ()>,
163 }
164 #[allow(clippy::match_single_binding)]
165 #[allow(clippy::reversed_empty_ranges)]
166 #[allow(clippy::single_match)]
167 impl<'de> _serde::de::Visitor<'de>
168 for __hkpAngFrictionConstraintAtomVisitor<'de> {
169 type Value = hkpAngFrictionConstraintAtom;
170 fn expecting(
171 &self,
172 __formatter: &mut core::fmt::Formatter,
173 ) -> core::fmt::Result {
174 core::fmt::Formatter::write_str(
175 __formatter,
176 "struct hkpAngFrictionConstraintAtom",
177 )
178 }
179 fn visit_struct_for_bytes<__A>(
180 self,
181 mut __map: __A,
182 ) -> _serde::__private::Result<Self::Value, __A::Error>
183 where
184 __A: _serde::de::MapAccess<'de>,
185 {
186 let __ptr = __A::class_ptr(&mut __map);
187 let parent = __A::parent_value(&mut __map)?;
188 let mut m_isEnabled: _serde::__private::Option<u8> = _serde::__private::None;
189 let mut m_firstFrictionAxis: _serde::__private::Option<u8> = _serde::__private::None;
190 let mut m_numFrictionAxes: _serde::__private::Option<u8> = _serde::__private::None;
191 let mut m_maxFrictionTorque: _serde::__private::Option<f32> = _serde::__private::None;
192 for i in 0..4usize {
193 match i {
194 0usize => {
195 if _serde::__private::Option::is_some(&m_isEnabled) {
196 return _serde::__private::Err(
197 <__A::Error as _serde::de::Error>::duplicate_field(
198 "isEnabled",
199 ),
200 );
201 }
202 m_isEnabled = _serde::__private::Some(
203 match __A::next_value::<u8>(&mut __map) {
204 _serde::__private::Ok(__val) => __val,
205 _serde::__private::Err(__err) => {
206 return _serde::__private::Err(__err);
207 }
208 },
209 );
210 }
211 1usize => {
212 if _serde::__private::Option::is_some(
213 &m_firstFrictionAxis,
214 ) {
215 return _serde::__private::Err(
216 <__A::Error as _serde::de::Error>::duplicate_field(
217 "firstFrictionAxis",
218 ),
219 );
220 }
221 m_firstFrictionAxis = _serde::__private::Some(
222 match __A::next_value::<u8>(&mut __map) {
223 _serde::__private::Ok(__val) => __val,
224 _serde::__private::Err(__err) => {
225 return _serde::__private::Err(__err);
226 }
227 },
228 );
229 }
230 2usize => {
231 if _serde::__private::Option::is_some(&m_numFrictionAxes) {
232 return _serde::__private::Err(
233 <__A::Error as _serde::de::Error>::duplicate_field(
234 "numFrictionAxes",
235 ),
236 );
237 }
238 m_numFrictionAxes = _serde::__private::Some(
239 match __A::next_value::<u8>(&mut __map) {
240 _serde::__private::Ok(__val) => __val,
241 _serde::__private::Err(__err) => {
242 return _serde::__private::Err(__err);
243 }
244 },
245 );
246 }
247 3usize => {
248 if _serde::__private::Option::is_some(
249 &m_maxFrictionTorque,
250 ) {
251 return _serde::__private::Err(
252 <__A::Error as _serde::de::Error>::duplicate_field(
253 "maxFrictionTorque",
254 ),
255 );
256 }
257 __A::pad(&mut __map, 3usize, 3usize)?;
258 m_maxFrictionTorque = _serde::__private::Some(
259 match __A::next_value::<f32>(&mut __map) {
260 _serde::__private::Ok(__val) => __val,
261 _serde::__private::Err(__err) => {
262 return _serde::__private::Err(__err);
263 }
264 },
265 );
266 }
267 _ => {}
268 }
269 }
270 let m_isEnabled = match m_isEnabled {
271 _serde::__private::Some(__field) => __field,
272 _serde::__private::None => {
273 return _serde::__private::Err(
274 <__A::Error as _serde::de::Error>::missing_field(
275 "isEnabled",
276 ),
277 );
278 }
279 };
280 let m_firstFrictionAxis = match m_firstFrictionAxis {
281 _serde::__private::Some(__field) => __field,
282 _serde::__private::None => {
283 return _serde::__private::Err(
284 <__A::Error as _serde::de::Error>::missing_field(
285 "firstFrictionAxis",
286 ),
287 );
288 }
289 };
290 let m_numFrictionAxes = match m_numFrictionAxes {
291 _serde::__private::Some(__field) => __field,
292 _serde::__private::None => {
293 return _serde::__private::Err(
294 <__A::Error as _serde::de::Error>::missing_field(
295 "numFrictionAxes",
296 ),
297 );
298 }
299 };
300 let m_maxFrictionTorque = match m_maxFrictionTorque {
301 _serde::__private::Some(__field) => __field,
302 _serde::__private::None => {
303 return _serde::__private::Err(
304 <__A::Error as _serde::de::Error>::missing_field(
305 "maxFrictionTorque",
306 ),
307 );
308 }
309 };
310 _serde::__private::Ok(hkpAngFrictionConstraintAtom {
311 __ptr,
312 parent,
313 m_isEnabled,
314 m_firstFrictionAxis,
315 m_numFrictionAxes,
316 m_maxFrictionTorque,
317 })
318 }
319 #[allow(clippy::manual_unwrap_or_default)]
320 fn visit_struct<__A>(
321 self,
322 mut __map: __A,
323 ) -> _serde::__private::Result<Self::Value, __A::Error>
324 where
325 __A: _serde::de::MapAccess<'de>,
326 {
327 let mut m_type: _serde::__private::Option<AtomType> = _serde::__private::None;
328 let mut m_isEnabled: _serde::__private::Option<u8> = _serde::__private::None;
329 let mut m_firstFrictionAxis: _serde::__private::Option<u8> = _serde::__private::None;
330 let mut m_numFrictionAxes: _serde::__private::Option<u8> = _serde::__private::None;
331 let mut m_maxFrictionTorque: _serde::__private::Option<f32> = _serde::__private::None;
332 while let _serde::__private::Some(__key) = {
333 __A::next_key::<__Field>(&mut __map)?
334 } {
335 match __key {
336 __Field::m_type => {
337 #[cfg(
338 any(feature = "strict", feature = "ignore_duplicates")
339 )]
340 if _serde::__private::Option::is_some(&m_type) {
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("type"),
349 );
350 }
351 m_type = _serde::__private::Some(
352 match __A::next_value::<AtomType>(&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_isEnabled => {
361 #[cfg(
362 any(feature = "strict", feature = "ignore_duplicates")
363 )]
364 if _serde::__private::Option::is_some(&m_isEnabled) {
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 "isEnabled",
374 ),
375 );
376 }
377 m_isEnabled = _serde::__private::Some(
378 match __A::next_value::<u8>(&mut __map) {
379 _serde::__private::Ok(__val) => __val,
380 _serde::__private::Err(__err) => {
381 return _serde::__private::Err(__err);
382 }
383 },
384 );
385 }
386 __Field::m_firstFrictionAxis => {
387 #[cfg(
388 any(feature = "strict", feature = "ignore_duplicates")
389 )]
390 if _serde::__private::Option::is_some(
391 &m_firstFrictionAxis,
392 ) {
393 #[cfg(feature = "ignore_duplicates")]
394 {
395 __A::skip_value(&mut __map)?;
396 continue;
397 }
398 #[cfg(feature = "strict")]
399 return _serde::__private::Err(
400 <__A::Error as _serde::de::Error>::duplicate_field(
401 "firstFrictionAxis",
402 ),
403 );
404 }
405 m_firstFrictionAxis = _serde::__private::Some(
406 match __A::next_value::<u8>(&mut __map) {
407 _serde::__private::Ok(__val) => __val,
408 _serde::__private::Err(__err) => {
409 return _serde::__private::Err(__err);
410 }
411 },
412 );
413 }
414 __Field::m_numFrictionAxes => {
415 #[cfg(
416 any(feature = "strict", feature = "ignore_duplicates")
417 )]
418 if _serde::__private::Option::is_some(&m_numFrictionAxes) {
419 #[cfg(feature = "ignore_duplicates")]
420 {
421 __A::skip_value(&mut __map)?;
422 continue;
423 }
424 #[cfg(feature = "strict")]
425 return _serde::__private::Err(
426 <__A::Error as _serde::de::Error>::duplicate_field(
427 "numFrictionAxes",
428 ),
429 );
430 }
431 m_numFrictionAxes = _serde::__private::Some(
432 match __A::next_value::<u8>(&mut __map) {
433 _serde::__private::Ok(__val) => __val,
434 _serde::__private::Err(__err) => {
435 return _serde::__private::Err(__err);
436 }
437 },
438 );
439 }
440 __Field::m_maxFrictionTorque => {
441 #[cfg(
442 any(feature = "strict", feature = "ignore_duplicates")
443 )]
444 if _serde::__private::Option::is_some(
445 &m_maxFrictionTorque,
446 ) {
447 #[cfg(feature = "ignore_duplicates")]
448 {
449 __A::skip_value(&mut __map)?;
450 continue;
451 }
452 #[cfg(feature = "strict")]
453 return _serde::__private::Err(
454 <__A::Error as _serde::de::Error>::duplicate_field(
455 "maxFrictionTorque",
456 ),
457 );
458 }
459 m_maxFrictionTorque = _serde::__private::Some(
460 match __A::next_value::<f32>(&mut __map) {
461 _serde::__private::Ok(__val) => __val,
462 _serde::__private::Err(__err) => {
463 return _serde::__private::Err(__err);
464 }
465 },
466 );
467 }
468 _ => __A::skip_value(&mut __map)?,
469 }
470 }
471 let m_type = match m_type {
472 _serde::__private::Some(__field) => __field,
473 _serde::__private::None => {
474 #[cfg(feature = "strict")]
475 return _serde::__private::Err(
476 <__A::Error as _serde::de::Error>::missing_field("type"),
477 );
478 #[cfg(not(feature = "strict"))] Default::default()
479 }
480 };
481 let m_isEnabled = match m_isEnabled {
482 _serde::__private::Some(__field) => __field,
483 _serde::__private::None => {
484 #[cfg(feature = "strict")]
485 return _serde::__private::Err(
486 <__A::Error as _serde::de::Error>::missing_field(
487 "isEnabled",
488 ),
489 );
490 #[cfg(not(feature = "strict"))] Default::default()
491 }
492 };
493 let m_firstFrictionAxis = match m_firstFrictionAxis {
494 _serde::__private::Some(__field) => __field,
495 _serde::__private::None => {
496 #[cfg(feature = "strict")]
497 return _serde::__private::Err(
498 <__A::Error as _serde::de::Error>::missing_field(
499 "firstFrictionAxis",
500 ),
501 );
502 #[cfg(not(feature = "strict"))] Default::default()
503 }
504 };
505 let m_numFrictionAxes = match m_numFrictionAxes {
506 _serde::__private::Some(__field) => __field,
507 _serde::__private::None => {
508 #[cfg(feature = "strict")]
509 return _serde::__private::Err(
510 <__A::Error as _serde::de::Error>::missing_field(
511 "numFrictionAxes",
512 ),
513 );
514 #[cfg(not(feature = "strict"))] Default::default()
515 }
516 };
517 let m_maxFrictionTorque = match m_maxFrictionTorque {
518 _serde::__private::Some(__field) => __field,
519 _serde::__private::None => {
520 #[cfg(feature = "strict")]
521 return _serde::__private::Err(
522 <__A::Error as _serde::de::Error>::missing_field(
523 "maxFrictionTorque",
524 ),
525 );
526 #[cfg(not(feature = "strict"))] Default::default()
527 }
528 };
529 let __ptr = None;
530 let parent = hkpConstraintAtom { __ptr, m_type };
531 let __ptr = __A::class_ptr(&mut __map);
532 _serde::__private::Ok(hkpAngFrictionConstraintAtom {
533 __ptr,
534 parent,
535 m_isEnabled,
536 m_firstFrictionAxis,
537 m_numFrictionAxes,
538 m_maxFrictionTorque,
539 })
540 }
541 }
542 const FIELDS: &[&str] = &[
543 "isEnabled",
544 "firstFrictionAxis",
545 "numFrictionAxes",
546 "maxFrictionTorque",
547 ];
548 _serde::Deserializer::deserialize_struct(
549 deserializer,
550 "hkpAngFrictionConstraintAtom",
551 FIELDS,
552 __hkpAngFrictionConstraintAtomVisitor {
553 marker: _serde::__private::PhantomData::<
554 hkpAngFrictionConstraintAtom,
555 >,
556 lifetime: _serde::__private::PhantomData,
557 },
558 )
559 }
560 }
561};