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