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