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