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 hkIndexedTransformSet<'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 pub parent: hkReferencedObject,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "matrices"))]
35 #[cfg_attr(feature = "serde", serde(rename = "matrices"))]
36 pub m_matrices: Vec<Matrix4>,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "inverseMatrices"))]
42 #[cfg_attr(feature = "serde", serde(rename = "inverseMatrices"))]
43 pub m_inverseMatrices: Vec<Matrix4>,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "matricesOrder"))]
49 #[cfg_attr(feature = "serde", serde(rename = "matricesOrder"))]
50 pub m_matricesOrder: Vec<i16>,
51 #[cfg_attr(feature = "serde", serde(borrow))]
56 #[cfg_attr(feature = "json_schema", schemars(rename = "matricesNames"))]
57 #[cfg_attr(feature = "serde", serde(rename = "matricesNames"))]
58 pub m_matricesNames: Vec<StringPtr<'a>>,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "indexMappings"))]
64 #[cfg_attr(feature = "serde", serde(rename = "indexMappings"))]
65 pub m_indexMappings: Vec<hkMeshBoneIndexMapping>,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "allMatricesAreAffine"))]
71 #[cfg_attr(feature = "serde", serde(rename = "allMatricesAreAffine"))]
72 pub m_allMatricesAreAffine: bool,
73}
74const _: () = {
75 use havok_serde as _serde;
76 impl<'a> _serde::HavokClass for hkIndexedTransformSet<'a> {
77 #[inline]
78 fn name(&self) -> &'static str {
79 "hkIndexedTransformSet"
80 }
81 #[inline]
82 fn signature(&self) -> _serde::__private::Signature {
83 _serde::__private::Signature::new(0x87fe6b5c)
84 }
85 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
86 fn deps_indexes(&self) -> Vec<usize> {
87 let mut v = Vec::new();
88 v.extend(
89 self
90 .m_indexMappings
91 .iter()
92 .flat_map(|class| class.deps_indexes())
93 .collect::<Vec<usize>>(),
94 );
95 v
96 }
97 }
98 impl<'a> _serde::Serialize for hkIndexedTransformSet<'a> {
99 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
100 where
101 S: _serde::ser::Serializer,
102 {
103 let class_meta = self
104 .__ptr
105 .map(|name| (name, _serde::__private::Signature::new(0x87fe6b5c)));
106 let mut serializer = __serializer
107 .serialize_struct("hkIndexedTransformSet", class_meta, (72u64, 104u64))?;
108 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
109 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
110 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
111 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
112 serializer
113 .serialize_array_field("matrices", &self.m_matrices, TypeSize::NonPtr)?;
114 serializer
115 .serialize_array_field(
116 "inverseMatrices",
117 &self.m_inverseMatrices,
118 TypeSize::NonPtr,
119 )?;
120 serializer
121 .serialize_array_field(
122 "matricesOrder",
123 &self.m_matricesOrder,
124 TypeSize::NonPtr,
125 )?;
126 serializer
127 .serialize_array_field(
128 "matricesNames",
129 &self.m_matricesNames,
130 TypeSize::String,
131 )?;
132 serializer
133 .serialize_array_field(
134 "indexMappings",
135 &self.m_indexMappings,
136 TypeSize::Struct {
137 size_x86: 12u64,
138 size_x86_64: 16u64,
139 },
140 )?;
141 serializer
142 .serialize_field("allMatricesAreAffine", &self.m_allMatricesAreAffine)?;
143 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
144 serializer.end()
145 }
146 }
147};
148#[doc(hidden)]
149#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
150const _: () = {
151 use havok_serde as _serde;
152 #[automatically_derived]
153 impl<'de> _serde::Deserialize<'de> for hkIndexedTransformSet<'de> {
154 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
155 where
156 __D: _serde::Deserializer<'de>,
157 {
158 #[allow(non_camel_case_types)]
159 enum __Field {
160 m_matrices,
161 m_inverseMatrices,
162 m_matricesOrder,
163 m_matricesNames,
164 m_indexMappings,
165 m_allMatricesAreAffine,
166 __ignore,
167 }
168 struct __FieldVisitor;
169 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
170 type Value = __Field;
171 fn expecting(
172 &self,
173 __formatter: &mut core::fmt::Formatter,
174 ) -> core::fmt::Result {
175 core::fmt::Formatter::write_str(__formatter, "field identifier")
176 }
177 #[allow(clippy::match_single_binding)]
179 #[allow(clippy::reversed_empty_ranges)]
180 #[allow(clippy::single_match)]
181 fn visit_key<__E>(
182 self,
183 __value: &str,
184 ) -> core::result::Result<Self::Value, __E>
185 where
186 __E: _serde::de::Error,
187 {
188 match __value {
189 "matrices" => Ok(__Field::m_matrices),
190 "inverseMatrices" => Ok(__Field::m_inverseMatrices),
191 "matricesOrder" => Ok(__Field::m_matricesOrder),
192 "matricesNames" => Ok(__Field::m_matricesNames),
193 "indexMappings" => Ok(__Field::m_indexMappings),
194 "allMatricesAreAffine" => Ok(__Field::m_allMatricesAreAffine),
195 _ => Ok(__Field::__ignore),
196 }
197 }
198 }
199 impl<'de> _serde::Deserialize<'de> for __Field {
200 #[inline]
201 fn deserialize<__D>(
202 __deserializer: __D,
203 ) -> core::result::Result<Self, __D::Error>
204 where
205 __D: _serde::Deserializer<'de>,
206 {
207 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
208 }
209 }
210 struct __hkIndexedTransformSetVisitor<'de> {
211 marker: _serde::__private::PhantomData<hkIndexedTransformSet<'de>>,
212 lifetime: _serde::__private::PhantomData<&'de ()>,
213 }
214 #[allow(clippy::match_single_binding)]
215 #[allow(clippy::reversed_empty_ranges)]
216 #[allow(clippy::single_match)]
217 impl<'de> _serde::de::Visitor<'de> for __hkIndexedTransformSetVisitor<'de> {
218 type Value = hkIndexedTransformSet<'de>;
219 fn expecting(
220 &self,
221 __formatter: &mut core::fmt::Formatter,
222 ) -> core::fmt::Result {
223 core::fmt::Formatter::write_str(
224 __formatter,
225 "struct hkIndexedTransformSet",
226 )
227 }
228 fn visit_struct_for_bytes<__A>(
229 self,
230 mut __map: __A,
231 ) -> _serde::__private::Result<Self::Value, __A::Error>
232 where
233 __A: _serde::de::MapAccess<'de>,
234 {
235 let __ptr = __A::class_ptr(&mut __map);
236 let parent = __A::parent_value(&mut __map)?;
237 let mut m_matrices: _serde::__private::Option<Vec<Matrix4>> = _serde::__private::None;
238 let mut m_inverseMatrices: _serde::__private::Option<Vec<Matrix4>> = _serde::__private::None;
239 let mut m_matricesOrder: _serde::__private::Option<Vec<i16>> = _serde::__private::None;
240 let mut m_matricesNames: _serde::__private::Option<
241 Vec<StringPtr<'de>>,
242 > = _serde::__private::None;
243 let mut m_indexMappings: _serde::__private::Option<
244 Vec<hkMeshBoneIndexMapping>,
245 > = _serde::__private::None;
246 let mut m_allMatricesAreAffine: _serde::__private::Option<bool> = _serde::__private::None;
247 for i in 0..6usize {
248 match i {
249 0usize => {
250 if _serde::__private::Option::is_some(&m_matrices) {
251 return _serde::__private::Err(
252 <__A::Error as _serde::de::Error>::duplicate_field(
253 "matrices",
254 ),
255 );
256 }
257 m_matrices = _serde::__private::Some(
258 match __A::next_value::<Vec<Matrix4>>(&mut __map) {
259 _serde::__private::Ok(__val) => __val,
260 _serde::__private::Err(__err) => {
261 return _serde::__private::Err(__err);
262 }
263 },
264 );
265 }
266 1usize => {
267 if _serde::__private::Option::is_some(&m_inverseMatrices) {
268 return _serde::__private::Err(
269 <__A::Error as _serde::de::Error>::duplicate_field(
270 "inverseMatrices",
271 ),
272 );
273 }
274 m_inverseMatrices = _serde::__private::Some(
275 match __A::next_value::<Vec<Matrix4>>(&mut __map) {
276 _serde::__private::Ok(__val) => __val,
277 _serde::__private::Err(__err) => {
278 return _serde::__private::Err(__err);
279 }
280 },
281 );
282 }
283 2usize => {
284 if _serde::__private::Option::is_some(&m_matricesOrder) {
285 return _serde::__private::Err(
286 <__A::Error as _serde::de::Error>::duplicate_field(
287 "matricesOrder",
288 ),
289 );
290 }
291 m_matricesOrder = _serde::__private::Some(
292 match __A::next_value::<Vec<i16>>(&mut __map) {
293 _serde::__private::Ok(__val) => __val,
294 _serde::__private::Err(__err) => {
295 return _serde::__private::Err(__err);
296 }
297 },
298 );
299 }
300 3usize => {
301 if _serde::__private::Option::is_some(&m_matricesNames) {
302 return _serde::__private::Err(
303 <__A::Error as _serde::de::Error>::duplicate_field(
304 "matricesNames",
305 ),
306 );
307 }
308 m_matricesNames = _serde::__private::Some(
309 match __A::next_value::<Vec<StringPtr<'de>>>(&mut __map) {
310 _serde::__private::Ok(__val) => __val,
311 _serde::__private::Err(__err) => {
312 return _serde::__private::Err(__err);
313 }
314 },
315 );
316 }
317 4usize => {
318 if _serde::__private::Option::is_some(&m_indexMappings) {
319 return _serde::__private::Err(
320 <__A::Error as _serde::de::Error>::duplicate_field(
321 "indexMappings",
322 ),
323 );
324 }
325 m_indexMappings = _serde::__private::Some(
326 match __A::next_value::<
327 Vec<hkMeshBoneIndexMapping>,
328 >(&mut __map) {
329 _serde::__private::Ok(__val) => __val,
330 _serde::__private::Err(__err) => {
331 return _serde::__private::Err(__err);
332 }
333 },
334 );
335 }
336 5usize => {
337 if _serde::__private::Option::is_some(
338 &m_allMatricesAreAffine,
339 ) {
340 return _serde::__private::Err(
341 <__A::Error as _serde::de::Error>::duplicate_field(
342 "allMatricesAreAffine",
343 ),
344 );
345 }
346 m_allMatricesAreAffine = _serde::__private::Some(
347 match __A::next_value::<bool>(&mut __map) {
348 _serde::__private::Ok(__val) => __val,
349 _serde::__private::Err(__err) => {
350 return _serde::__private::Err(__err);
351 }
352 },
353 );
354 }
355 _ => {}
356 }
357 }
358 __A::pad(&mut __map, 3usize, 7usize)?;
359 let m_matrices = match m_matrices {
360 _serde::__private::Some(__field) => __field,
361 _serde::__private::None => {
362 return _serde::__private::Err(
363 <__A::Error as _serde::de::Error>::missing_field("matrices"),
364 );
365 }
366 };
367 let m_inverseMatrices = match m_inverseMatrices {
368 _serde::__private::Some(__field) => __field,
369 _serde::__private::None => {
370 return _serde::__private::Err(
371 <__A::Error as _serde::de::Error>::missing_field(
372 "inverseMatrices",
373 ),
374 );
375 }
376 };
377 let m_matricesOrder = match m_matricesOrder {
378 _serde::__private::Some(__field) => __field,
379 _serde::__private::None => {
380 return _serde::__private::Err(
381 <__A::Error as _serde::de::Error>::missing_field(
382 "matricesOrder",
383 ),
384 );
385 }
386 };
387 let m_matricesNames = match m_matricesNames {
388 _serde::__private::Some(__field) => __field,
389 _serde::__private::None => {
390 return _serde::__private::Err(
391 <__A::Error as _serde::de::Error>::missing_field(
392 "matricesNames",
393 ),
394 );
395 }
396 };
397 let m_indexMappings = match m_indexMappings {
398 _serde::__private::Some(__field) => __field,
399 _serde::__private::None => {
400 return _serde::__private::Err(
401 <__A::Error as _serde::de::Error>::missing_field(
402 "indexMappings",
403 ),
404 );
405 }
406 };
407 let m_allMatricesAreAffine = match m_allMatricesAreAffine {
408 _serde::__private::Some(__field) => __field,
409 _serde::__private::None => {
410 return _serde::__private::Err(
411 <__A::Error as _serde::de::Error>::missing_field(
412 "allMatricesAreAffine",
413 ),
414 );
415 }
416 };
417 _serde::__private::Ok(hkIndexedTransformSet {
418 __ptr,
419 parent,
420 m_matrices,
421 m_inverseMatrices,
422 m_matricesOrder,
423 m_matricesNames,
424 m_indexMappings,
425 m_allMatricesAreAffine,
426 })
427 }
428 #[allow(clippy::manual_unwrap_or_default)]
429 fn visit_struct<__A>(
430 self,
431 mut __map: __A,
432 ) -> _serde::__private::Result<Self::Value, __A::Error>
433 where
434 __A: _serde::de::MapAccess<'de>,
435 {
436 let mut m_matrices: _serde::__private::Option<Vec<Matrix4>> = _serde::__private::None;
437 let mut m_inverseMatrices: _serde::__private::Option<Vec<Matrix4>> = _serde::__private::None;
438 let mut m_matricesOrder: _serde::__private::Option<Vec<i16>> = _serde::__private::None;
439 let mut m_matricesNames: _serde::__private::Option<
440 Vec<StringPtr<'de>>,
441 > = _serde::__private::None;
442 let mut m_indexMappings: _serde::__private::Option<
443 Vec<hkMeshBoneIndexMapping>,
444 > = _serde::__private::None;
445 let mut m_allMatricesAreAffine: _serde::__private::Option<bool> = _serde::__private::None;
446 while let _serde::__private::Some(__key) = {
447 __A::next_key::<__Field>(&mut __map)?
448 } {
449 match __key {
450 __Field::m_matrices => {
451 #[cfg(
452 any(feature = "strict", feature = "ignore_duplicates")
453 )]
454 if _serde::__private::Option::is_some(&m_matrices) {
455 #[cfg(feature = "ignore_duplicates")]
456 {
457 __A::skip_value(&mut __map)?;
458 continue;
459 }
460 #[cfg(feature = "strict")]
461 return _serde::__private::Err(
462 <__A::Error as _serde::de::Error>::duplicate_field(
463 "matrices",
464 ),
465 );
466 }
467 m_matrices = _serde::__private::Some(
468 match __A::next_value::<Vec<Matrix4>>(&mut __map) {
469 _serde::__private::Ok(__val) => __val,
470 _serde::__private::Err(__err) => {
471 return _serde::__private::Err(__err);
472 }
473 },
474 );
475 }
476 __Field::m_inverseMatrices => {
477 #[cfg(
478 any(feature = "strict", feature = "ignore_duplicates")
479 )]
480 if _serde::__private::Option::is_some(&m_inverseMatrices) {
481 #[cfg(feature = "ignore_duplicates")]
482 {
483 __A::skip_value(&mut __map)?;
484 continue;
485 }
486 #[cfg(feature = "strict")]
487 return _serde::__private::Err(
488 <__A::Error as _serde::de::Error>::duplicate_field(
489 "inverseMatrices",
490 ),
491 );
492 }
493 m_inverseMatrices = _serde::__private::Some(
494 match __A::next_value::<Vec<Matrix4>>(&mut __map) {
495 _serde::__private::Ok(__val) => __val,
496 _serde::__private::Err(__err) => {
497 return _serde::__private::Err(__err);
498 }
499 },
500 );
501 }
502 __Field::m_matricesOrder => {
503 #[cfg(
504 any(feature = "strict", feature = "ignore_duplicates")
505 )]
506 if _serde::__private::Option::is_some(&m_matricesOrder) {
507 #[cfg(feature = "ignore_duplicates")]
508 {
509 __A::skip_value(&mut __map)?;
510 continue;
511 }
512 #[cfg(feature = "strict")]
513 return _serde::__private::Err(
514 <__A::Error as _serde::de::Error>::duplicate_field(
515 "matricesOrder",
516 ),
517 );
518 }
519 m_matricesOrder = _serde::__private::Some(
520 match __A::next_value::<Vec<i16>>(&mut __map) {
521 _serde::__private::Ok(__val) => __val,
522 _serde::__private::Err(__err) => {
523 return _serde::__private::Err(__err);
524 }
525 },
526 );
527 }
528 __Field::m_matricesNames => {
529 #[cfg(
530 any(feature = "strict", feature = "ignore_duplicates")
531 )]
532 if _serde::__private::Option::is_some(&m_matricesNames) {
533 #[cfg(feature = "ignore_duplicates")]
534 {
535 __A::skip_value(&mut __map)?;
536 continue;
537 }
538 #[cfg(feature = "strict")]
539 return _serde::__private::Err(
540 <__A::Error as _serde::de::Error>::duplicate_field(
541 "matricesNames",
542 ),
543 );
544 }
545 m_matricesNames = _serde::__private::Some(
546 match __A::next_value::<Vec<StringPtr<'de>>>(&mut __map) {
547 _serde::__private::Ok(__val) => __val,
548 _serde::__private::Err(__err) => {
549 return _serde::__private::Err(__err);
550 }
551 },
552 );
553 }
554 __Field::m_indexMappings => {
555 #[cfg(
556 any(feature = "strict", feature = "ignore_duplicates")
557 )]
558 if _serde::__private::Option::is_some(&m_indexMappings) {
559 #[cfg(feature = "ignore_duplicates")]
560 {
561 __A::skip_value(&mut __map)?;
562 continue;
563 }
564 #[cfg(feature = "strict")]
565 return _serde::__private::Err(
566 <__A::Error as _serde::de::Error>::duplicate_field(
567 "indexMappings",
568 ),
569 );
570 }
571 m_indexMappings = _serde::__private::Some(
572 match __A::next_value::<
573 Vec<hkMeshBoneIndexMapping>,
574 >(&mut __map) {
575 _serde::__private::Ok(__val) => __val,
576 _serde::__private::Err(__err) => {
577 return _serde::__private::Err(__err);
578 }
579 },
580 );
581 }
582 __Field::m_allMatricesAreAffine => {
583 #[cfg(
584 any(feature = "strict", feature = "ignore_duplicates")
585 )]
586 if _serde::__private::Option::is_some(
587 &m_allMatricesAreAffine,
588 ) {
589 #[cfg(feature = "ignore_duplicates")]
590 {
591 __A::skip_value(&mut __map)?;
592 continue;
593 }
594 #[cfg(feature = "strict")]
595 return _serde::__private::Err(
596 <__A::Error as _serde::de::Error>::duplicate_field(
597 "allMatricesAreAffine",
598 ),
599 );
600 }
601 m_allMatricesAreAffine = _serde::__private::Some(
602 match __A::next_value::<bool>(&mut __map) {
603 _serde::__private::Ok(__val) => __val,
604 _serde::__private::Err(__err) => {
605 return _serde::__private::Err(__err);
606 }
607 },
608 );
609 }
610 _ => __A::skip_value(&mut __map)?,
611 }
612 }
613 let m_matrices = match m_matrices {
614 _serde::__private::Some(__field) => __field,
615 _serde::__private::None => {
616 #[cfg(feature = "strict")]
617 return _serde::__private::Err(
618 <__A::Error as _serde::de::Error>::missing_field("matrices"),
619 );
620 #[cfg(not(feature = "strict"))] Default::default()
621 }
622 };
623 let m_inverseMatrices = match m_inverseMatrices {
624 _serde::__private::Some(__field) => __field,
625 _serde::__private::None => {
626 #[cfg(feature = "strict")]
627 return _serde::__private::Err(
628 <__A::Error as _serde::de::Error>::missing_field(
629 "inverseMatrices",
630 ),
631 );
632 #[cfg(not(feature = "strict"))] Default::default()
633 }
634 };
635 let m_matricesOrder = match m_matricesOrder {
636 _serde::__private::Some(__field) => __field,
637 _serde::__private::None => {
638 #[cfg(feature = "strict")]
639 return _serde::__private::Err(
640 <__A::Error as _serde::de::Error>::missing_field(
641 "matricesOrder",
642 ),
643 );
644 #[cfg(not(feature = "strict"))] Default::default()
645 }
646 };
647 let m_matricesNames = match m_matricesNames {
648 _serde::__private::Some(__field) => __field,
649 _serde::__private::None => {
650 #[cfg(feature = "strict")]
651 return _serde::__private::Err(
652 <__A::Error as _serde::de::Error>::missing_field(
653 "matricesNames",
654 ),
655 );
656 #[cfg(not(feature = "strict"))] Default::default()
657 }
658 };
659 let m_indexMappings = match m_indexMappings {
660 _serde::__private::Some(__field) => __field,
661 _serde::__private::None => {
662 #[cfg(feature = "strict")]
663 return _serde::__private::Err(
664 <__A::Error as _serde::de::Error>::missing_field(
665 "indexMappings",
666 ),
667 );
668 #[cfg(not(feature = "strict"))] Default::default()
669 }
670 };
671 let m_allMatricesAreAffine = match m_allMatricesAreAffine {
672 _serde::__private::Some(__field) => __field,
673 _serde::__private::None => {
674 #[cfg(feature = "strict")]
675 return _serde::__private::Err(
676 <__A::Error as _serde::de::Error>::missing_field(
677 "allMatricesAreAffine",
678 ),
679 );
680 #[cfg(not(feature = "strict"))] Default::default()
681 }
682 };
683 let __ptr = None;
684 let parent = hkBaseObject { __ptr };
685 let parent = hkReferencedObject {
686 __ptr,
687 parent,
688 ..Default::default()
689 };
690 let __ptr = __A::class_ptr(&mut __map);
691 _serde::__private::Ok(hkIndexedTransformSet {
692 __ptr,
693 parent,
694 m_matrices,
695 m_inverseMatrices,
696 m_matricesOrder,
697 m_matricesNames,
698 m_indexMappings,
699 m_allMatricesAreAffine,
700 })
701 }
702 }
703 const FIELDS: &[&str] = &[
704 "matrices",
705 "inverseMatrices",
706 "matricesOrder",
707 "matricesNames",
708 "indexMappings",
709 "allMatricesAreAffine",
710 ];
711 _serde::Deserializer::deserialize_struct(
712 deserializer,
713 "hkIndexedTransformSet",
714 FIELDS,
715 __hkIndexedTransformSetVisitor {
716 marker: _serde::__private::PhantomData::<hkIndexedTransformSet>,
717 lifetime: _serde::__private::PhantomData,
718 },
719 )
720 }
721 }
722};