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