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