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