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