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