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