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