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