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 hkxVertexBufferVertexData {
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 = "vectorData"))]
31 #[cfg_attr(feature = "serde", serde(rename = "vectorData"))]
32 pub m_vectorData: Vec<Vector4>,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "floatData"))]
38 #[cfg_attr(feature = "serde", serde(rename = "floatData"))]
39 pub m_floatData: Vec<f32>,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "uint32Data"))]
45 #[cfg_attr(feature = "serde", serde(rename = "uint32Data"))]
46 pub m_uint32Data: Vec<u32>,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "uint16Data"))]
52 #[cfg_attr(feature = "serde", serde(rename = "uint16Data"))]
53 pub m_uint16Data: Vec<u16>,
54 #[cfg_attr(feature = "json_schema", schemars(rename = "uint8Data"))]
59 #[cfg_attr(feature = "serde", serde(rename = "uint8Data"))]
60 pub m_uint8Data: Vec<u8>,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "numVerts"))]
66 #[cfg_attr(feature = "serde", serde(rename = "numVerts"))]
67 pub m_numVerts: u32,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "vectorStride"))]
73 #[cfg_attr(feature = "serde", serde(rename = "vectorStride"))]
74 pub m_vectorStride: u32,
75 #[cfg_attr(feature = "json_schema", schemars(rename = "floatStride"))]
80 #[cfg_attr(feature = "serde", serde(rename = "floatStride"))]
81 pub m_floatStride: u32,
82 #[cfg_attr(feature = "json_schema", schemars(rename = "uint32Stride"))]
87 #[cfg_attr(feature = "serde", serde(rename = "uint32Stride"))]
88 pub m_uint32Stride: u32,
89 #[cfg_attr(feature = "json_schema", schemars(rename = "uint16Stride"))]
94 #[cfg_attr(feature = "serde", serde(rename = "uint16Stride"))]
95 pub m_uint16Stride: u32,
96 #[cfg_attr(feature = "json_schema", schemars(rename = "uint8Stride"))]
101 #[cfg_attr(feature = "serde", serde(rename = "uint8Stride"))]
102 pub m_uint8Stride: u32,
103}
104const _: () = {
105 use havok_serde as _serde;
106 impl _serde::HavokClass for hkxVertexBufferVertexData {
107 #[inline]
108 fn name(&self) -> &'static str {
109 "hkxVertexBufferVertexData"
110 }
111 #[inline]
112 fn signature(&self) -> _serde::__private::Signature {
113 _serde::__private::Signature::new(0xd72b6fd0)
114 }
115 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
116 fn deps_indexes(&self) -> Vec<usize> {
117 let mut v = Vec::new();
118 v
119 }
120 }
121 impl _serde::Serialize for hkxVertexBufferVertexData {
122 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
123 where
124 S: _serde::ser::Serializer,
125 {
126 let class_meta = self
127 .__ptr
128 .map(|name| (name, _serde::__private::Signature::new(0xd72b6fd0)));
129 let mut serializer = __serializer
130 .serialize_struct(
131 "hkxVertexBufferVertexData",
132 class_meta,
133 (84u64, 104u64),
134 )?;
135 serializer
136 .serialize_array_field(
137 "vectorData",
138 &self.m_vectorData,
139 TypeSize::NonPtr,
140 )?;
141 serializer
142 .serialize_array_field(
143 "floatData",
144 &self.m_floatData,
145 TypeSize::NonPtr,
146 )?;
147 serializer
148 .serialize_array_field(
149 "uint32Data",
150 &self.m_uint32Data,
151 TypeSize::NonPtr,
152 )?;
153 serializer
154 .serialize_array_field(
155 "uint16Data",
156 &self.m_uint16Data,
157 TypeSize::NonPtr,
158 )?;
159 serializer
160 .serialize_array_field(
161 "uint8Data",
162 &self.m_uint8Data,
163 TypeSize::NonPtr,
164 )?;
165 serializer.serialize_field("numVerts", &self.m_numVerts)?;
166 serializer.serialize_field("vectorStride", &self.m_vectorStride)?;
167 serializer.serialize_field("floatStride", &self.m_floatStride)?;
168 serializer.serialize_field("uint32Stride", &self.m_uint32Stride)?;
169 serializer.serialize_field("uint16Stride", &self.m_uint16Stride)?;
170 serializer.serialize_field("uint8Stride", &self.m_uint8Stride)?;
171 serializer.end()
172 }
173 }
174};
175#[doc(hidden)]
176#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
177const _: () = {
178 use havok_serde as _serde;
179 #[automatically_derived]
180 impl<'de> _serde::Deserialize<'de> for hkxVertexBufferVertexData {
181 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
182 where
183 __D: _serde::Deserializer<'de>,
184 {
185 #[allow(non_camel_case_types)]
186 enum __Field {
187 m_vectorData,
188 m_floatData,
189 m_uint32Data,
190 m_uint16Data,
191 m_uint8Data,
192 m_numVerts,
193 m_vectorStride,
194 m_floatStride,
195 m_uint32Stride,
196 m_uint16Stride,
197 m_uint8Stride,
198 __ignore,
199 }
200 struct __FieldVisitor;
201 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
202 type Value = __Field;
203 fn expecting(
204 &self,
205 __formatter: &mut core::fmt::Formatter,
206 ) -> core::fmt::Result {
207 core::fmt::Formatter::write_str(__formatter, "field identifier")
208 }
209 #[allow(clippy::match_single_binding)]
211 #[allow(clippy::reversed_empty_ranges)]
212 #[allow(clippy::single_match)]
213 fn visit_key<__E>(
214 self,
215 __value: &str,
216 ) -> core::result::Result<Self::Value, __E>
217 where
218 __E: _serde::de::Error,
219 {
220 match __value {
221 "vectorData" => Ok(__Field::m_vectorData),
222 "floatData" => Ok(__Field::m_floatData),
223 "uint32Data" => Ok(__Field::m_uint32Data),
224 "uint16Data" => Ok(__Field::m_uint16Data),
225 "uint8Data" => Ok(__Field::m_uint8Data),
226 "numVerts" => Ok(__Field::m_numVerts),
227 "vectorStride" => Ok(__Field::m_vectorStride),
228 "floatStride" => Ok(__Field::m_floatStride),
229 "uint32Stride" => Ok(__Field::m_uint32Stride),
230 "uint16Stride" => Ok(__Field::m_uint16Stride),
231 "uint8Stride" => Ok(__Field::m_uint8Stride),
232 _ => Ok(__Field::__ignore),
233 }
234 }
235 }
236 impl<'de> _serde::Deserialize<'de> for __Field {
237 #[inline]
238 fn deserialize<__D>(
239 __deserializer: __D,
240 ) -> core::result::Result<Self, __D::Error>
241 where
242 __D: _serde::Deserializer<'de>,
243 {
244 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
245 }
246 }
247 struct __hkxVertexBufferVertexDataVisitor<'de> {
248 marker: _serde::__private::PhantomData<hkxVertexBufferVertexData>,
249 lifetime: _serde::__private::PhantomData<&'de ()>,
250 }
251 #[allow(clippy::match_single_binding)]
252 #[allow(clippy::reversed_empty_ranges)]
253 #[allow(clippy::single_match)]
254 impl<'de> _serde::de::Visitor<'de>
255 for __hkxVertexBufferVertexDataVisitor<'de> {
256 type Value = hkxVertexBufferVertexData;
257 fn expecting(
258 &self,
259 __formatter: &mut core::fmt::Formatter,
260 ) -> core::fmt::Result {
261 core::fmt::Formatter::write_str(
262 __formatter,
263 "struct hkxVertexBufferVertexData",
264 )
265 }
266 fn visit_struct_for_bytes<__A>(
267 self,
268 mut __map: __A,
269 ) -> _serde::__private::Result<Self::Value, __A::Error>
270 where
271 __A: _serde::de::MapAccess<'de>,
272 {
273 let __ptr = __A::class_ptr(&mut __map);
274 let mut m_vectorData: _serde::__private::Option<Vec<Vector4>> = _serde::__private::None;
275 let mut m_floatData: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
276 let mut m_uint32Data: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
277 let mut m_uint16Data: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
278 let mut m_uint8Data: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
279 let mut m_numVerts: _serde::__private::Option<u32> = _serde::__private::None;
280 let mut m_vectorStride: _serde::__private::Option<u32> = _serde::__private::None;
281 let mut m_floatStride: _serde::__private::Option<u32> = _serde::__private::None;
282 let mut m_uint32Stride: _serde::__private::Option<u32> = _serde::__private::None;
283 let mut m_uint16Stride: _serde::__private::Option<u32> = _serde::__private::None;
284 let mut m_uint8Stride: _serde::__private::Option<u32> = _serde::__private::None;
285 for i in 0..11usize {
286 match i {
287 0usize => {
288 if _serde::__private::Option::is_some(&m_vectorData) {
289 return _serde::__private::Err(
290 <__A::Error as _serde::de::Error>::duplicate_field(
291 "vectorData",
292 ),
293 );
294 }
295 m_vectorData = _serde::__private::Some(
296 match __A::next_value::<Vec<Vector4>>(&mut __map) {
297 _serde::__private::Ok(__val) => __val,
298 _serde::__private::Err(__err) => {
299 return _serde::__private::Err(__err);
300 }
301 },
302 );
303 }
304 1usize => {
305 if _serde::__private::Option::is_some(&m_floatData) {
306 return _serde::__private::Err(
307 <__A::Error as _serde::de::Error>::duplicate_field(
308 "floatData",
309 ),
310 );
311 }
312 m_floatData = _serde::__private::Some(
313 match __A::next_value::<Vec<f32>>(&mut __map) {
314 _serde::__private::Ok(__val) => __val,
315 _serde::__private::Err(__err) => {
316 return _serde::__private::Err(__err);
317 }
318 },
319 );
320 }
321 2usize => {
322 if _serde::__private::Option::is_some(&m_uint32Data) {
323 return _serde::__private::Err(
324 <__A::Error as _serde::de::Error>::duplicate_field(
325 "uint32Data",
326 ),
327 );
328 }
329 m_uint32Data = _serde::__private::Some(
330 match __A::next_value::<Vec<u32>>(&mut __map) {
331 _serde::__private::Ok(__val) => __val,
332 _serde::__private::Err(__err) => {
333 return _serde::__private::Err(__err);
334 }
335 },
336 );
337 }
338 3usize => {
339 if _serde::__private::Option::is_some(&m_uint16Data) {
340 return _serde::__private::Err(
341 <__A::Error as _serde::de::Error>::duplicate_field(
342 "uint16Data",
343 ),
344 );
345 }
346 m_uint16Data = _serde::__private::Some(
347 match __A::next_value::<Vec<u16>>(&mut __map) {
348 _serde::__private::Ok(__val) => __val,
349 _serde::__private::Err(__err) => {
350 return _serde::__private::Err(__err);
351 }
352 },
353 );
354 }
355 4usize => {
356 if _serde::__private::Option::is_some(&m_uint8Data) {
357 return _serde::__private::Err(
358 <__A::Error as _serde::de::Error>::duplicate_field(
359 "uint8Data",
360 ),
361 );
362 }
363 m_uint8Data = _serde::__private::Some(
364 match __A::next_value::<Vec<u8>>(&mut __map) {
365 _serde::__private::Ok(__val) => __val,
366 _serde::__private::Err(__err) => {
367 return _serde::__private::Err(__err);
368 }
369 },
370 );
371 }
372 5usize => {
373 if _serde::__private::Option::is_some(&m_numVerts) {
374 return _serde::__private::Err(
375 <__A::Error as _serde::de::Error>::duplicate_field(
376 "numVerts",
377 ),
378 );
379 }
380 m_numVerts = _serde::__private::Some(
381 match __A::next_value::<u32>(&mut __map) {
382 _serde::__private::Ok(__val) => __val,
383 _serde::__private::Err(__err) => {
384 return _serde::__private::Err(__err);
385 }
386 },
387 );
388 }
389 6usize => {
390 if _serde::__private::Option::is_some(&m_vectorStride) {
391 return _serde::__private::Err(
392 <__A::Error as _serde::de::Error>::duplicate_field(
393 "vectorStride",
394 ),
395 );
396 }
397 m_vectorStride = _serde::__private::Some(
398 match __A::next_value::<u32>(&mut __map) {
399 _serde::__private::Ok(__val) => __val,
400 _serde::__private::Err(__err) => {
401 return _serde::__private::Err(__err);
402 }
403 },
404 );
405 }
406 7usize => {
407 if _serde::__private::Option::is_some(&m_floatStride) {
408 return _serde::__private::Err(
409 <__A::Error as _serde::de::Error>::duplicate_field(
410 "floatStride",
411 ),
412 );
413 }
414 m_floatStride = _serde::__private::Some(
415 match __A::next_value::<u32>(&mut __map) {
416 _serde::__private::Ok(__val) => __val,
417 _serde::__private::Err(__err) => {
418 return _serde::__private::Err(__err);
419 }
420 },
421 );
422 }
423 8usize => {
424 if _serde::__private::Option::is_some(&m_uint32Stride) {
425 return _serde::__private::Err(
426 <__A::Error as _serde::de::Error>::duplicate_field(
427 "uint32Stride",
428 ),
429 );
430 }
431 m_uint32Stride = _serde::__private::Some(
432 match __A::next_value::<u32>(&mut __map) {
433 _serde::__private::Ok(__val) => __val,
434 _serde::__private::Err(__err) => {
435 return _serde::__private::Err(__err);
436 }
437 },
438 );
439 }
440 9usize => {
441 if _serde::__private::Option::is_some(&m_uint16Stride) {
442 return _serde::__private::Err(
443 <__A::Error as _serde::de::Error>::duplicate_field(
444 "uint16Stride",
445 ),
446 );
447 }
448 m_uint16Stride = _serde::__private::Some(
449 match __A::next_value::<u32>(&mut __map) {
450 _serde::__private::Ok(__val) => __val,
451 _serde::__private::Err(__err) => {
452 return _serde::__private::Err(__err);
453 }
454 },
455 );
456 }
457 10usize => {
458 if _serde::__private::Option::is_some(&m_uint8Stride) {
459 return _serde::__private::Err(
460 <__A::Error as _serde::de::Error>::duplicate_field(
461 "uint8Stride",
462 ),
463 );
464 }
465 m_uint8Stride = _serde::__private::Some(
466 match __A::next_value::<u32>(&mut __map) {
467 _serde::__private::Ok(__val) => __val,
468 _serde::__private::Err(__err) => {
469 return _serde::__private::Err(__err);
470 }
471 },
472 );
473 }
474 _ => {}
475 }
476 }
477 let m_vectorData = match m_vectorData {
478 _serde::__private::Some(__field) => __field,
479 _serde::__private::None => {
480 return _serde::__private::Err(
481 <__A::Error as _serde::de::Error>::missing_field(
482 "vectorData",
483 ),
484 );
485 }
486 };
487 let m_floatData = match m_floatData {
488 _serde::__private::Some(__field) => __field,
489 _serde::__private::None => {
490 return _serde::__private::Err(
491 <__A::Error as _serde::de::Error>::missing_field(
492 "floatData",
493 ),
494 );
495 }
496 };
497 let m_uint32Data = match m_uint32Data {
498 _serde::__private::Some(__field) => __field,
499 _serde::__private::None => {
500 return _serde::__private::Err(
501 <__A::Error as _serde::de::Error>::missing_field(
502 "uint32Data",
503 ),
504 );
505 }
506 };
507 let m_uint16Data = match m_uint16Data {
508 _serde::__private::Some(__field) => __field,
509 _serde::__private::None => {
510 return _serde::__private::Err(
511 <__A::Error as _serde::de::Error>::missing_field(
512 "uint16Data",
513 ),
514 );
515 }
516 };
517 let m_uint8Data = match m_uint8Data {
518 _serde::__private::Some(__field) => __field,
519 _serde::__private::None => {
520 return _serde::__private::Err(
521 <__A::Error as _serde::de::Error>::missing_field(
522 "uint8Data",
523 ),
524 );
525 }
526 };
527 let m_numVerts = match m_numVerts {
528 _serde::__private::Some(__field) => __field,
529 _serde::__private::None => {
530 return _serde::__private::Err(
531 <__A::Error as _serde::de::Error>::missing_field("numVerts"),
532 );
533 }
534 };
535 let m_vectorStride = match m_vectorStride {
536 _serde::__private::Some(__field) => __field,
537 _serde::__private::None => {
538 return _serde::__private::Err(
539 <__A::Error as _serde::de::Error>::missing_field(
540 "vectorStride",
541 ),
542 );
543 }
544 };
545 let m_floatStride = match m_floatStride {
546 _serde::__private::Some(__field) => __field,
547 _serde::__private::None => {
548 return _serde::__private::Err(
549 <__A::Error as _serde::de::Error>::missing_field(
550 "floatStride",
551 ),
552 );
553 }
554 };
555 let m_uint32Stride = match m_uint32Stride {
556 _serde::__private::Some(__field) => __field,
557 _serde::__private::None => {
558 return _serde::__private::Err(
559 <__A::Error as _serde::de::Error>::missing_field(
560 "uint32Stride",
561 ),
562 );
563 }
564 };
565 let m_uint16Stride = match m_uint16Stride {
566 _serde::__private::Some(__field) => __field,
567 _serde::__private::None => {
568 return _serde::__private::Err(
569 <__A::Error as _serde::de::Error>::missing_field(
570 "uint16Stride",
571 ),
572 );
573 }
574 };
575 let m_uint8Stride = match m_uint8Stride {
576 _serde::__private::Some(__field) => __field,
577 _serde::__private::None => {
578 return _serde::__private::Err(
579 <__A::Error as _serde::de::Error>::missing_field(
580 "uint8Stride",
581 ),
582 );
583 }
584 };
585 _serde::__private::Ok(hkxVertexBufferVertexData {
586 __ptr,
587 m_vectorData,
588 m_floatData,
589 m_uint32Data,
590 m_uint16Data,
591 m_uint8Data,
592 m_numVerts,
593 m_vectorStride,
594 m_floatStride,
595 m_uint32Stride,
596 m_uint16Stride,
597 m_uint8Stride,
598 })
599 }
600 #[allow(clippy::manual_unwrap_or_default)]
601 fn visit_struct<__A>(
602 self,
603 mut __map: __A,
604 ) -> _serde::__private::Result<Self::Value, __A::Error>
605 where
606 __A: _serde::de::MapAccess<'de>,
607 {
608 let mut m_vectorData: _serde::__private::Option<Vec<Vector4>> = _serde::__private::None;
609 let mut m_floatData: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
610 let mut m_uint32Data: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
611 let mut m_uint16Data: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
612 let mut m_uint8Data: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
613 let mut m_numVerts: _serde::__private::Option<u32> = _serde::__private::None;
614 let mut m_vectorStride: _serde::__private::Option<u32> = _serde::__private::None;
615 let mut m_floatStride: _serde::__private::Option<u32> = _serde::__private::None;
616 let mut m_uint32Stride: _serde::__private::Option<u32> = _serde::__private::None;
617 let mut m_uint16Stride: _serde::__private::Option<u32> = _serde::__private::None;
618 let mut m_uint8Stride: _serde::__private::Option<u32> = _serde::__private::None;
619 while let _serde::__private::Some(__key) = {
620 __A::next_key::<__Field>(&mut __map)?
621 } {
622 match __key {
623 __Field::m_vectorData => {
624 #[cfg(
625 any(feature = "strict", feature = "ignore_duplicates")
626 )]
627 if _serde::__private::Option::is_some(&m_vectorData) {
628 #[cfg(feature = "ignore_duplicates")]
629 {
630 __A::skip_value(&mut __map)?;
631 continue;
632 }
633 #[cfg(feature = "strict")]
634 return _serde::__private::Err(
635 <__A::Error as _serde::de::Error>::duplicate_field(
636 "vectorData",
637 ),
638 );
639 }
640 m_vectorData = _serde::__private::Some(
641 match __A::next_value::<Vec<Vector4>>(&mut __map) {
642 _serde::__private::Ok(__val) => __val,
643 _serde::__private::Err(__err) => {
644 return _serde::__private::Err(__err);
645 }
646 },
647 );
648 }
649 __Field::m_floatData => {
650 #[cfg(
651 any(feature = "strict", feature = "ignore_duplicates")
652 )]
653 if _serde::__private::Option::is_some(&m_floatData) {
654 #[cfg(feature = "ignore_duplicates")]
655 {
656 __A::skip_value(&mut __map)?;
657 continue;
658 }
659 #[cfg(feature = "strict")]
660 return _serde::__private::Err(
661 <__A::Error as _serde::de::Error>::duplicate_field(
662 "floatData",
663 ),
664 );
665 }
666 m_floatData = _serde::__private::Some(
667 match __A::next_value::<Vec<f32>>(&mut __map) {
668 _serde::__private::Ok(__val) => __val,
669 _serde::__private::Err(__err) => {
670 return _serde::__private::Err(__err);
671 }
672 },
673 );
674 }
675 __Field::m_uint32Data => {
676 #[cfg(
677 any(feature = "strict", feature = "ignore_duplicates")
678 )]
679 if _serde::__private::Option::is_some(&m_uint32Data) {
680 #[cfg(feature = "ignore_duplicates")]
681 {
682 __A::skip_value(&mut __map)?;
683 continue;
684 }
685 #[cfg(feature = "strict")]
686 return _serde::__private::Err(
687 <__A::Error as _serde::de::Error>::duplicate_field(
688 "uint32Data",
689 ),
690 );
691 }
692 m_uint32Data = _serde::__private::Some(
693 match __A::next_value::<Vec<u32>>(&mut __map) {
694 _serde::__private::Ok(__val) => __val,
695 _serde::__private::Err(__err) => {
696 return _serde::__private::Err(__err);
697 }
698 },
699 );
700 }
701 __Field::m_uint16Data => {
702 #[cfg(
703 any(feature = "strict", feature = "ignore_duplicates")
704 )]
705 if _serde::__private::Option::is_some(&m_uint16Data) {
706 #[cfg(feature = "ignore_duplicates")]
707 {
708 __A::skip_value(&mut __map)?;
709 continue;
710 }
711 #[cfg(feature = "strict")]
712 return _serde::__private::Err(
713 <__A::Error as _serde::de::Error>::duplicate_field(
714 "uint16Data",
715 ),
716 );
717 }
718 m_uint16Data = _serde::__private::Some(
719 match __A::next_value::<Vec<u16>>(&mut __map) {
720 _serde::__private::Ok(__val) => __val,
721 _serde::__private::Err(__err) => {
722 return _serde::__private::Err(__err);
723 }
724 },
725 );
726 }
727 __Field::m_uint8Data => {
728 #[cfg(
729 any(feature = "strict", feature = "ignore_duplicates")
730 )]
731 if _serde::__private::Option::is_some(&m_uint8Data) {
732 #[cfg(feature = "ignore_duplicates")]
733 {
734 __A::skip_value(&mut __map)?;
735 continue;
736 }
737 #[cfg(feature = "strict")]
738 return _serde::__private::Err(
739 <__A::Error as _serde::de::Error>::duplicate_field(
740 "uint8Data",
741 ),
742 );
743 }
744 m_uint8Data = _serde::__private::Some(
745 match __A::next_value::<Vec<u8>>(&mut __map) {
746 _serde::__private::Ok(__val) => __val,
747 _serde::__private::Err(__err) => {
748 return _serde::__private::Err(__err);
749 }
750 },
751 );
752 }
753 __Field::m_numVerts => {
754 #[cfg(
755 any(feature = "strict", feature = "ignore_duplicates")
756 )]
757 if _serde::__private::Option::is_some(&m_numVerts) {
758 #[cfg(feature = "ignore_duplicates")]
759 {
760 __A::skip_value(&mut __map)?;
761 continue;
762 }
763 #[cfg(feature = "strict")]
764 return _serde::__private::Err(
765 <__A::Error as _serde::de::Error>::duplicate_field(
766 "numVerts",
767 ),
768 );
769 }
770 m_numVerts = _serde::__private::Some(
771 match __A::next_value::<u32>(&mut __map) {
772 _serde::__private::Ok(__val) => __val,
773 _serde::__private::Err(__err) => {
774 return _serde::__private::Err(__err);
775 }
776 },
777 );
778 }
779 __Field::m_vectorStride => {
780 #[cfg(
781 any(feature = "strict", feature = "ignore_duplicates")
782 )]
783 if _serde::__private::Option::is_some(&m_vectorStride) {
784 #[cfg(feature = "ignore_duplicates")]
785 {
786 __A::skip_value(&mut __map)?;
787 continue;
788 }
789 #[cfg(feature = "strict")]
790 return _serde::__private::Err(
791 <__A::Error as _serde::de::Error>::duplicate_field(
792 "vectorStride",
793 ),
794 );
795 }
796 m_vectorStride = _serde::__private::Some(
797 match __A::next_value::<u32>(&mut __map) {
798 _serde::__private::Ok(__val) => __val,
799 _serde::__private::Err(__err) => {
800 return _serde::__private::Err(__err);
801 }
802 },
803 );
804 }
805 __Field::m_floatStride => {
806 #[cfg(
807 any(feature = "strict", feature = "ignore_duplicates")
808 )]
809 if _serde::__private::Option::is_some(&m_floatStride) {
810 #[cfg(feature = "ignore_duplicates")]
811 {
812 __A::skip_value(&mut __map)?;
813 continue;
814 }
815 #[cfg(feature = "strict")]
816 return _serde::__private::Err(
817 <__A::Error as _serde::de::Error>::duplicate_field(
818 "floatStride",
819 ),
820 );
821 }
822 m_floatStride = _serde::__private::Some(
823 match __A::next_value::<u32>(&mut __map) {
824 _serde::__private::Ok(__val) => __val,
825 _serde::__private::Err(__err) => {
826 return _serde::__private::Err(__err);
827 }
828 },
829 );
830 }
831 __Field::m_uint32Stride => {
832 #[cfg(
833 any(feature = "strict", feature = "ignore_duplicates")
834 )]
835 if _serde::__private::Option::is_some(&m_uint32Stride) {
836 #[cfg(feature = "ignore_duplicates")]
837 {
838 __A::skip_value(&mut __map)?;
839 continue;
840 }
841 #[cfg(feature = "strict")]
842 return _serde::__private::Err(
843 <__A::Error as _serde::de::Error>::duplicate_field(
844 "uint32Stride",
845 ),
846 );
847 }
848 m_uint32Stride = _serde::__private::Some(
849 match __A::next_value::<u32>(&mut __map) {
850 _serde::__private::Ok(__val) => __val,
851 _serde::__private::Err(__err) => {
852 return _serde::__private::Err(__err);
853 }
854 },
855 );
856 }
857 __Field::m_uint16Stride => {
858 #[cfg(
859 any(feature = "strict", feature = "ignore_duplicates")
860 )]
861 if _serde::__private::Option::is_some(&m_uint16Stride) {
862 #[cfg(feature = "ignore_duplicates")]
863 {
864 __A::skip_value(&mut __map)?;
865 continue;
866 }
867 #[cfg(feature = "strict")]
868 return _serde::__private::Err(
869 <__A::Error as _serde::de::Error>::duplicate_field(
870 "uint16Stride",
871 ),
872 );
873 }
874 m_uint16Stride = _serde::__private::Some(
875 match __A::next_value::<u32>(&mut __map) {
876 _serde::__private::Ok(__val) => __val,
877 _serde::__private::Err(__err) => {
878 return _serde::__private::Err(__err);
879 }
880 },
881 );
882 }
883 __Field::m_uint8Stride => {
884 #[cfg(
885 any(feature = "strict", feature = "ignore_duplicates")
886 )]
887 if _serde::__private::Option::is_some(&m_uint8Stride) {
888 #[cfg(feature = "ignore_duplicates")]
889 {
890 __A::skip_value(&mut __map)?;
891 continue;
892 }
893 #[cfg(feature = "strict")]
894 return _serde::__private::Err(
895 <__A::Error as _serde::de::Error>::duplicate_field(
896 "uint8Stride",
897 ),
898 );
899 }
900 m_uint8Stride = _serde::__private::Some(
901 match __A::next_value::<u32>(&mut __map) {
902 _serde::__private::Ok(__val) => __val,
903 _serde::__private::Err(__err) => {
904 return _serde::__private::Err(__err);
905 }
906 },
907 );
908 }
909 _ => __A::skip_value(&mut __map)?,
910 }
911 }
912 let m_vectorData = match m_vectorData {
913 _serde::__private::Some(__field) => __field,
914 _serde::__private::None => {
915 #[cfg(feature = "strict")]
916 return _serde::__private::Err(
917 <__A::Error as _serde::de::Error>::missing_field(
918 "vectorData",
919 ),
920 );
921 #[cfg(not(feature = "strict"))] Default::default()
922 }
923 };
924 let m_floatData = match m_floatData {
925 _serde::__private::Some(__field) => __field,
926 _serde::__private::None => {
927 #[cfg(feature = "strict")]
928 return _serde::__private::Err(
929 <__A::Error as _serde::de::Error>::missing_field(
930 "floatData",
931 ),
932 );
933 #[cfg(not(feature = "strict"))] Default::default()
934 }
935 };
936 let m_uint32Data = match m_uint32Data {
937 _serde::__private::Some(__field) => __field,
938 _serde::__private::None => {
939 #[cfg(feature = "strict")]
940 return _serde::__private::Err(
941 <__A::Error as _serde::de::Error>::missing_field(
942 "uint32Data",
943 ),
944 );
945 #[cfg(not(feature = "strict"))] Default::default()
946 }
947 };
948 let m_uint16Data = match m_uint16Data {
949 _serde::__private::Some(__field) => __field,
950 _serde::__private::None => {
951 #[cfg(feature = "strict")]
952 return _serde::__private::Err(
953 <__A::Error as _serde::de::Error>::missing_field(
954 "uint16Data",
955 ),
956 );
957 #[cfg(not(feature = "strict"))] Default::default()
958 }
959 };
960 let m_uint8Data = match m_uint8Data {
961 _serde::__private::Some(__field) => __field,
962 _serde::__private::None => {
963 #[cfg(feature = "strict")]
964 return _serde::__private::Err(
965 <__A::Error as _serde::de::Error>::missing_field(
966 "uint8Data",
967 ),
968 );
969 #[cfg(not(feature = "strict"))] Default::default()
970 }
971 };
972 let m_numVerts = match m_numVerts {
973 _serde::__private::Some(__field) => __field,
974 _serde::__private::None => {
975 #[cfg(feature = "strict")]
976 return _serde::__private::Err(
977 <__A::Error as _serde::de::Error>::missing_field("numVerts"),
978 );
979 #[cfg(not(feature = "strict"))] Default::default()
980 }
981 };
982 let m_vectorStride = match m_vectorStride {
983 _serde::__private::Some(__field) => __field,
984 _serde::__private::None => {
985 #[cfg(feature = "strict")]
986 return _serde::__private::Err(
987 <__A::Error as _serde::de::Error>::missing_field(
988 "vectorStride",
989 ),
990 );
991 #[cfg(not(feature = "strict"))] Default::default()
992 }
993 };
994 let m_floatStride = match m_floatStride {
995 _serde::__private::Some(__field) => __field,
996 _serde::__private::None => {
997 #[cfg(feature = "strict")]
998 return _serde::__private::Err(
999 <__A::Error as _serde::de::Error>::missing_field(
1000 "floatStride",
1001 ),
1002 );
1003 #[cfg(not(feature = "strict"))] Default::default()
1004 }
1005 };
1006 let m_uint32Stride = match m_uint32Stride {
1007 _serde::__private::Some(__field) => __field,
1008 _serde::__private::None => {
1009 #[cfg(feature = "strict")]
1010 return _serde::__private::Err(
1011 <__A::Error as _serde::de::Error>::missing_field(
1012 "uint32Stride",
1013 ),
1014 );
1015 #[cfg(not(feature = "strict"))] Default::default()
1016 }
1017 };
1018 let m_uint16Stride = match m_uint16Stride {
1019 _serde::__private::Some(__field) => __field,
1020 _serde::__private::None => {
1021 #[cfg(feature = "strict")]
1022 return _serde::__private::Err(
1023 <__A::Error as _serde::de::Error>::missing_field(
1024 "uint16Stride",
1025 ),
1026 );
1027 #[cfg(not(feature = "strict"))] Default::default()
1028 }
1029 };
1030 let m_uint8Stride = match m_uint8Stride {
1031 _serde::__private::Some(__field) => __field,
1032 _serde::__private::None => {
1033 #[cfg(feature = "strict")]
1034 return _serde::__private::Err(
1035 <__A::Error as _serde::de::Error>::missing_field(
1036 "uint8Stride",
1037 ),
1038 );
1039 #[cfg(not(feature = "strict"))] Default::default()
1040 }
1041 };
1042 let __ptr = __A::class_ptr(&mut __map);
1043 _serde::__private::Ok(hkxVertexBufferVertexData {
1044 __ptr,
1045 m_vectorData,
1046 m_floatData,
1047 m_uint32Data,
1048 m_uint16Data,
1049 m_uint8Data,
1050 m_numVerts,
1051 m_vectorStride,
1052 m_floatStride,
1053 m_uint32Stride,
1054 m_uint16Stride,
1055 m_uint8Stride,
1056 })
1057 }
1058 }
1059 const FIELDS: &[&str] = &[
1060 "vectorData",
1061 "floatData",
1062 "uint32Data",
1063 "uint16Data",
1064 "uint8Data",
1065 "numVerts",
1066 "vectorStride",
1067 "floatStride",
1068 "uint32Stride",
1069 "uint16Stride",
1070 "uint8Stride",
1071 ];
1072 _serde::Deserializer::deserialize_struct(
1073 deserializer,
1074 "hkxVertexBufferVertexData",
1075 FIELDS,
1076 __hkxVertexBufferVertexDataVisitor {
1077 marker: _serde::__private::PhantomData::<hkxVertexBufferVertexData>,
1078 lifetime: _serde::__private::PhantomData,
1079 },
1080 )
1081 }
1082 }
1083};