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