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