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