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 hkbMirroredSkeletonInfo {
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 = "mirrorAxis"))]
35 #[cfg_attr(feature = "serde", serde(rename = "mirrorAxis"))]
36 pub m_mirrorAxis: Vector4,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "bonePairMap"))]
42 #[cfg_attr(feature = "serde", serde(rename = "bonePairMap"))]
43 pub m_bonePairMap: Vec<i16>,
44}
45const _: () = {
46 use havok_serde as _serde;
47 impl _serde::HavokClass for hkbMirroredSkeletonInfo {
48 #[inline]
49 fn name(&self) -> &'static str {
50 "hkbMirroredSkeletonInfo"
51 }
52 #[inline]
53 fn signature(&self) -> _serde::__private::Signature {
54 _serde::__private::Signature::new(0xc6c2da4f)
55 }
56 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
57 fn deps_indexes(&self) -> Vec<usize> {
58 let mut v = Vec::new();
59 v
60 }
61 }
62 impl _serde::Serialize for hkbMirroredSkeletonInfo {
63 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
64 where
65 S: _serde::ser::Serializer,
66 {
67 let class_meta = self
68 .__ptr
69 .map(|name| (name, _serde::__private::Signature::new(0xc6c2da4f)));
70 let mut serializer = __serializer
71 .serialize_struct(
72 "hkbMirroredSkeletonInfo",
73 class_meta,
74 (48u64, 48u64),
75 )?;
76 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
77 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
78 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
79 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
80 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
81 serializer.serialize_field("mirrorAxis", &self.m_mirrorAxis)?;
82 serializer
83 .serialize_array_field(
84 "bonePairMap",
85 &self.m_bonePairMap,
86 TypeSize::NonPtr,
87 )?;
88 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
89 serializer.end()
90 }
91 }
92};
93#[doc(hidden)]
94#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
95const _: () = {
96 use havok_serde as _serde;
97 #[automatically_derived]
98 impl<'de> _serde::Deserialize<'de> for hkbMirroredSkeletonInfo {
99 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
100 where
101 __D: _serde::Deserializer<'de>,
102 {
103 #[allow(non_camel_case_types)]
104 enum __Field {
105 m_mirrorAxis,
106 m_bonePairMap,
107 __ignore,
108 }
109 struct __FieldVisitor;
110 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
111 type Value = __Field;
112 fn expecting(
113 &self,
114 __formatter: &mut core::fmt::Formatter,
115 ) -> core::fmt::Result {
116 core::fmt::Formatter::write_str(__formatter, "field identifier")
117 }
118 #[allow(clippy::match_single_binding)]
120 #[allow(clippy::reversed_empty_ranges)]
121 #[allow(clippy::single_match)]
122 fn visit_key<__E>(
123 self,
124 __value: &str,
125 ) -> core::result::Result<Self::Value, __E>
126 where
127 __E: _serde::de::Error,
128 {
129 match __value {
130 "mirrorAxis" => Ok(__Field::m_mirrorAxis),
131 "bonePairMap" => Ok(__Field::m_bonePairMap),
132 _ => Ok(__Field::__ignore),
133 }
134 }
135 }
136 impl<'de> _serde::Deserialize<'de> for __Field {
137 #[inline]
138 fn deserialize<__D>(
139 __deserializer: __D,
140 ) -> core::result::Result<Self, __D::Error>
141 where
142 __D: _serde::Deserializer<'de>,
143 {
144 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
145 }
146 }
147 struct __hkbMirroredSkeletonInfoVisitor<'de> {
148 marker: _serde::__private::PhantomData<hkbMirroredSkeletonInfo>,
149 lifetime: _serde::__private::PhantomData<&'de ()>,
150 }
151 #[allow(clippy::match_single_binding)]
152 #[allow(clippy::reversed_empty_ranges)]
153 #[allow(clippy::single_match)]
154 impl<'de> _serde::de::Visitor<'de>
155 for __hkbMirroredSkeletonInfoVisitor<'de> {
156 type Value = hkbMirroredSkeletonInfo;
157 fn expecting(
158 &self,
159 __formatter: &mut core::fmt::Formatter,
160 ) -> core::fmt::Result {
161 core::fmt::Formatter::write_str(
162 __formatter,
163 "struct hkbMirroredSkeletonInfo",
164 )
165 }
166 fn visit_struct_for_bytes<__A>(
167 self,
168 mut __map: __A,
169 ) -> _serde::__private::Result<Self::Value, __A::Error>
170 where
171 __A: _serde::de::MapAccess<'de>,
172 {
173 let __ptr = __A::class_ptr(&mut __map);
174 let parent = __A::parent_value(&mut __map)?;
175 let mut m_mirrorAxis: _serde::__private::Option<Vector4> = _serde::__private::None;
176 let mut m_bonePairMap: _serde::__private::Option<Vec<i16>> = _serde::__private::None;
177 for i in 0..2usize {
178 match i {
179 0usize => {
180 if _serde::__private::Option::is_some(&m_mirrorAxis) {
181 return _serde::__private::Err(
182 <__A::Error as _serde::de::Error>::duplicate_field(
183 "mirrorAxis",
184 ),
185 );
186 }
187 __A::pad(&mut __map, 8usize, 0usize)?;
188 m_mirrorAxis = _serde::__private::Some(
189 match __A::next_value::<Vector4>(&mut __map) {
190 _serde::__private::Ok(__val) => __val,
191 _serde::__private::Err(__err) => {
192 return _serde::__private::Err(__err);
193 }
194 },
195 );
196 }
197 1usize => {
198 if _serde::__private::Option::is_some(&m_bonePairMap) {
199 return _serde::__private::Err(
200 <__A::Error as _serde::de::Error>::duplicate_field(
201 "bonePairMap",
202 ),
203 );
204 }
205 m_bonePairMap = _serde::__private::Some(
206 match __A::next_value::<Vec<i16>>(&mut __map) {
207 _serde::__private::Ok(__val) => __val,
208 _serde::__private::Err(__err) => {
209 return _serde::__private::Err(__err);
210 }
211 },
212 );
213 }
214 _ => {}
215 }
216 }
217 __A::pad(&mut __map, 4usize, 0usize)?;
218 let m_mirrorAxis = match m_mirrorAxis {
219 _serde::__private::Some(__field) => __field,
220 _serde::__private::None => {
221 return _serde::__private::Err(
222 <__A::Error as _serde::de::Error>::missing_field(
223 "mirrorAxis",
224 ),
225 );
226 }
227 };
228 let m_bonePairMap = match m_bonePairMap {
229 _serde::__private::Some(__field) => __field,
230 _serde::__private::None => {
231 return _serde::__private::Err(
232 <__A::Error as _serde::de::Error>::missing_field(
233 "bonePairMap",
234 ),
235 );
236 }
237 };
238 _serde::__private::Ok(hkbMirroredSkeletonInfo {
239 __ptr,
240 parent,
241 m_mirrorAxis,
242 m_bonePairMap,
243 })
244 }
245 #[allow(clippy::manual_unwrap_or_default)]
246 fn visit_struct<__A>(
247 self,
248 mut __map: __A,
249 ) -> _serde::__private::Result<Self::Value, __A::Error>
250 where
251 __A: _serde::de::MapAccess<'de>,
252 {
253 let mut m_mirrorAxis: _serde::__private::Option<Vector4> = _serde::__private::None;
254 let mut m_bonePairMap: _serde::__private::Option<Vec<i16>> = _serde::__private::None;
255 while let _serde::__private::Some(__key) = {
256 __A::next_key::<__Field>(&mut __map)?
257 } {
258 match __key {
259 __Field::m_mirrorAxis => {
260 #[cfg(
261 any(feature = "strict", feature = "ignore_duplicates")
262 )]
263 if _serde::__private::Option::is_some(&m_mirrorAxis) {
264 #[cfg(feature = "ignore_duplicates")]
265 {
266 __A::skip_value(&mut __map)?;
267 continue;
268 }
269 #[cfg(feature = "strict")]
270 return _serde::__private::Err(
271 <__A::Error as _serde::de::Error>::duplicate_field(
272 "mirrorAxis",
273 ),
274 );
275 }
276 m_mirrorAxis = _serde::__private::Some(
277 match __A::next_value::<Vector4>(&mut __map) {
278 _serde::__private::Ok(__val) => __val,
279 _serde::__private::Err(__err) => {
280 return _serde::__private::Err(__err);
281 }
282 },
283 );
284 }
285 __Field::m_bonePairMap => {
286 #[cfg(
287 any(feature = "strict", feature = "ignore_duplicates")
288 )]
289 if _serde::__private::Option::is_some(&m_bonePairMap) {
290 #[cfg(feature = "ignore_duplicates")]
291 {
292 __A::skip_value(&mut __map)?;
293 continue;
294 }
295 #[cfg(feature = "strict")]
296 return _serde::__private::Err(
297 <__A::Error as _serde::de::Error>::duplicate_field(
298 "bonePairMap",
299 ),
300 );
301 }
302 m_bonePairMap = _serde::__private::Some(
303 match __A::next_value::<Vec<i16>>(&mut __map) {
304 _serde::__private::Ok(__val) => __val,
305 _serde::__private::Err(__err) => {
306 return _serde::__private::Err(__err);
307 }
308 },
309 );
310 }
311 _ => __A::skip_value(&mut __map)?,
312 }
313 }
314 let m_mirrorAxis = match m_mirrorAxis {
315 _serde::__private::Some(__field) => __field,
316 _serde::__private::None => {
317 #[cfg(feature = "strict")]
318 return _serde::__private::Err(
319 <__A::Error as _serde::de::Error>::missing_field(
320 "mirrorAxis",
321 ),
322 );
323 #[cfg(not(feature = "strict"))] Default::default()
324 }
325 };
326 let m_bonePairMap = match m_bonePairMap {
327 _serde::__private::Some(__field) => __field,
328 _serde::__private::None => {
329 #[cfg(feature = "strict")]
330 return _serde::__private::Err(
331 <__A::Error as _serde::de::Error>::missing_field(
332 "bonePairMap",
333 ),
334 );
335 #[cfg(not(feature = "strict"))] Default::default()
336 }
337 };
338 let __ptr = None;
339 let parent = hkBaseObject { __ptr };
340 let parent = hkReferencedObject {
341 __ptr,
342 parent,
343 ..Default::default()
344 };
345 let __ptr = __A::class_ptr(&mut __map);
346 _serde::__private::Ok(hkbMirroredSkeletonInfo {
347 __ptr,
348 parent,
349 m_mirrorAxis,
350 m_bonePairMap,
351 })
352 }
353 }
354 const FIELDS: &[&str] = &["mirrorAxis", "bonePairMap"];
355 _serde::Deserializer::deserialize_struct(
356 deserializer,
357 "hkbMirroredSkeletonInfo",
358 FIELDS,
359 __hkbMirroredSkeletonInfoVisitor {
360 marker: _serde::__private::PhantomData::<hkbMirroredSkeletonInfo>,
361 lifetime: _serde::__private::PhantomData,
362 },
363 )
364 }
365 }
366};