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