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