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