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 hkMultipleVertexBufferLockedElement {
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 = "vertexBufferIndex"))]
31 #[cfg_attr(feature = "serde", serde(rename = "vertexBufferIndex"))]
32 pub m_vertexBufferIndex: u8,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "elementIndex"))]
38 #[cfg_attr(feature = "serde", serde(rename = "elementIndex"))]
39 pub m_elementIndex: u8,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "lockedBufferIndex"))]
45 #[cfg_attr(feature = "serde", serde(rename = "lockedBufferIndex"))]
46 pub m_lockedBufferIndex: u8,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "vertexFormatIndex"))]
52 #[cfg_attr(feature = "serde", serde(rename = "vertexFormatIndex"))]
53 pub m_vertexFormatIndex: u8,
54 #[cfg_attr(feature = "json_schema", schemars(rename = "lockFlags"))]
59 #[cfg_attr(feature = "serde", serde(rename = "lockFlags"))]
60 pub m_lockFlags: u8,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "outputBufferIndex"))]
66 #[cfg_attr(feature = "serde", serde(rename = "outputBufferIndex"))]
67 pub m_outputBufferIndex: u8,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "emulatedIndex"))]
73 #[cfg_attr(feature = "serde", serde(rename = "emulatedIndex"))]
74 pub m_emulatedIndex: i8,
75}
76const _: () = {
77 use havok_serde as _serde;
78 impl _serde::HavokClass for hkMultipleVertexBufferLockedElement {
79 #[inline]
80 fn name(&self) -> &'static str {
81 "hkMultipleVertexBufferLockedElement"
82 }
83 #[inline]
84 fn signature(&self) -> _serde::__private::Signature {
85 _serde::__private::Signature::new(0xa0e22afc)
86 }
87 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
88 fn deps_indexes(&self) -> Vec<usize> {
89 let mut v = Vec::new();
90 v
91 }
92 }
93 impl _serde::Serialize for hkMultipleVertexBufferLockedElement {
94 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
95 where
96 S: _serde::ser::Serializer,
97 {
98 let class_meta = self
99 .__ptr
100 .map(|name| (name, _serde::__private::Signature::new(0xa0e22afc)));
101 let mut serializer = __serializer
102 .serialize_struct(
103 "hkMultipleVertexBufferLockedElement",
104 class_meta,
105 (7u64, 7u64),
106 )?;
107 serializer.serialize_field("vertexBufferIndex", &self.m_vertexBufferIndex)?;
108 serializer.serialize_field("elementIndex", &self.m_elementIndex)?;
109 serializer.serialize_field("lockedBufferIndex", &self.m_lockedBufferIndex)?;
110 serializer.serialize_field("vertexFormatIndex", &self.m_vertexFormatIndex)?;
111 serializer.serialize_field("lockFlags", &self.m_lockFlags)?;
112 serializer.serialize_field("outputBufferIndex", &self.m_outputBufferIndex)?;
113 serializer.serialize_field("emulatedIndex", &self.m_emulatedIndex)?;
114 serializer.end()
115 }
116 }
117};
118#[doc(hidden)]
119#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
120const _: () = {
121 use havok_serde as _serde;
122 #[automatically_derived]
123 impl<'de> _serde::Deserialize<'de> for hkMultipleVertexBufferLockedElement {
124 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
125 where
126 __D: _serde::Deserializer<'de>,
127 {
128 #[allow(non_camel_case_types)]
129 enum __Field {
130 m_vertexBufferIndex,
131 m_elementIndex,
132 m_lockedBufferIndex,
133 m_vertexFormatIndex,
134 m_lockFlags,
135 m_outputBufferIndex,
136 m_emulatedIndex,
137 __ignore,
138 }
139 struct __FieldVisitor;
140 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
141 type Value = __Field;
142 fn expecting(
143 &self,
144 __formatter: &mut core::fmt::Formatter,
145 ) -> core::fmt::Result {
146 core::fmt::Formatter::write_str(__formatter, "field identifier")
147 }
148 #[allow(clippy::match_single_binding)]
150 #[allow(clippy::reversed_empty_ranges)]
151 #[allow(clippy::single_match)]
152 fn visit_key<__E>(
153 self,
154 __value: &str,
155 ) -> core::result::Result<Self::Value, __E>
156 where
157 __E: _serde::de::Error,
158 {
159 match __value {
160 "vertexBufferIndex" => Ok(__Field::m_vertexBufferIndex),
161 "elementIndex" => Ok(__Field::m_elementIndex),
162 "lockedBufferIndex" => Ok(__Field::m_lockedBufferIndex),
163 "vertexFormatIndex" => Ok(__Field::m_vertexFormatIndex),
164 "lockFlags" => Ok(__Field::m_lockFlags),
165 "outputBufferIndex" => Ok(__Field::m_outputBufferIndex),
166 "emulatedIndex" => Ok(__Field::m_emulatedIndex),
167 _ => Ok(__Field::__ignore),
168 }
169 }
170 }
171 impl<'de> _serde::Deserialize<'de> for __Field {
172 #[inline]
173 fn deserialize<__D>(
174 __deserializer: __D,
175 ) -> core::result::Result<Self, __D::Error>
176 where
177 __D: _serde::Deserializer<'de>,
178 {
179 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
180 }
181 }
182 struct __hkMultipleVertexBufferLockedElementVisitor<'de> {
183 marker: _serde::__private::PhantomData<
184 hkMultipleVertexBufferLockedElement,
185 >,
186 lifetime: _serde::__private::PhantomData<&'de ()>,
187 }
188 #[allow(clippy::match_single_binding)]
189 #[allow(clippy::reversed_empty_ranges)]
190 #[allow(clippy::single_match)]
191 impl<'de> _serde::de::Visitor<'de>
192 for __hkMultipleVertexBufferLockedElementVisitor<'de> {
193 type Value = hkMultipleVertexBufferLockedElement;
194 fn expecting(
195 &self,
196 __formatter: &mut core::fmt::Formatter,
197 ) -> core::fmt::Result {
198 core::fmt::Formatter::write_str(
199 __formatter,
200 "struct hkMultipleVertexBufferLockedElement",
201 )
202 }
203 fn visit_struct_for_bytes<__A>(
204 self,
205 mut __map: __A,
206 ) -> _serde::__private::Result<Self::Value, __A::Error>
207 where
208 __A: _serde::de::MapAccess<'de>,
209 {
210 let __ptr = __A::class_ptr(&mut __map);
211 let mut m_vertexBufferIndex: _serde::__private::Option<u8> = _serde::__private::None;
212 let mut m_elementIndex: _serde::__private::Option<u8> = _serde::__private::None;
213 let mut m_lockedBufferIndex: _serde::__private::Option<u8> = _serde::__private::None;
214 let mut m_vertexFormatIndex: _serde::__private::Option<u8> = _serde::__private::None;
215 let mut m_lockFlags: _serde::__private::Option<u8> = _serde::__private::None;
216 let mut m_outputBufferIndex: _serde::__private::Option<u8> = _serde::__private::None;
217 let mut m_emulatedIndex: _serde::__private::Option<i8> = _serde::__private::None;
218 for i in 0..7usize {
219 match i {
220 0usize => {
221 if _serde::__private::Option::is_some(
222 &m_vertexBufferIndex,
223 ) {
224 return _serde::__private::Err(
225 <__A::Error as _serde::de::Error>::duplicate_field(
226 "vertexBufferIndex",
227 ),
228 );
229 }
230 m_vertexBufferIndex = _serde::__private::Some(
231 match __A::next_value::<u8>(&mut __map) {
232 _serde::__private::Ok(__val) => __val,
233 _serde::__private::Err(__err) => {
234 return _serde::__private::Err(__err);
235 }
236 },
237 );
238 }
239 1usize => {
240 if _serde::__private::Option::is_some(&m_elementIndex) {
241 return _serde::__private::Err(
242 <__A::Error as _serde::de::Error>::duplicate_field(
243 "elementIndex",
244 ),
245 );
246 }
247 m_elementIndex = _serde::__private::Some(
248 match __A::next_value::<u8>(&mut __map) {
249 _serde::__private::Ok(__val) => __val,
250 _serde::__private::Err(__err) => {
251 return _serde::__private::Err(__err);
252 }
253 },
254 );
255 }
256 2usize => {
257 if _serde::__private::Option::is_some(
258 &m_lockedBufferIndex,
259 ) {
260 return _serde::__private::Err(
261 <__A::Error as _serde::de::Error>::duplicate_field(
262 "lockedBufferIndex",
263 ),
264 );
265 }
266 m_lockedBufferIndex = _serde::__private::Some(
267 match __A::next_value::<u8>(&mut __map) {
268 _serde::__private::Ok(__val) => __val,
269 _serde::__private::Err(__err) => {
270 return _serde::__private::Err(__err);
271 }
272 },
273 );
274 }
275 3usize => {
276 if _serde::__private::Option::is_some(
277 &m_vertexFormatIndex,
278 ) {
279 return _serde::__private::Err(
280 <__A::Error as _serde::de::Error>::duplicate_field(
281 "vertexFormatIndex",
282 ),
283 );
284 }
285 m_vertexFormatIndex = _serde::__private::Some(
286 match __A::next_value::<u8>(&mut __map) {
287 _serde::__private::Ok(__val) => __val,
288 _serde::__private::Err(__err) => {
289 return _serde::__private::Err(__err);
290 }
291 },
292 );
293 }
294 4usize => {
295 if _serde::__private::Option::is_some(&m_lockFlags) {
296 return _serde::__private::Err(
297 <__A::Error as _serde::de::Error>::duplicate_field(
298 "lockFlags",
299 ),
300 );
301 }
302 m_lockFlags = _serde::__private::Some(
303 match __A::next_value::<u8>(&mut __map) {
304 _serde::__private::Ok(__val) => __val,
305 _serde::__private::Err(__err) => {
306 return _serde::__private::Err(__err);
307 }
308 },
309 );
310 }
311 5usize => {
312 if _serde::__private::Option::is_some(
313 &m_outputBufferIndex,
314 ) {
315 return _serde::__private::Err(
316 <__A::Error as _serde::de::Error>::duplicate_field(
317 "outputBufferIndex",
318 ),
319 );
320 }
321 m_outputBufferIndex = _serde::__private::Some(
322 match __A::next_value::<u8>(&mut __map) {
323 _serde::__private::Ok(__val) => __val,
324 _serde::__private::Err(__err) => {
325 return _serde::__private::Err(__err);
326 }
327 },
328 );
329 }
330 6usize => {
331 if _serde::__private::Option::is_some(&m_emulatedIndex) {
332 return _serde::__private::Err(
333 <__A::Error as _serde::de::Error>::duplicate_field(
334 "emulatedIndex",
335 ),
336 );
337 }
338 m_emulatedIndex = _serde::__private::Some(
339 match __A::next_value::<i8>(&mut __map) {
340 _serde::__private::Ok(__val) => __val,
341 _serde::__private::Err(__err) => {
342 return _serde::__private::Err(__err);
343 }
344 },
345 );
346 }
347 _ => {}
348 }
349 }
350 let m_vertexBufferIndex = match m_vertexBufferIndex {
351 _serde::__private::Some(__field) => __field,
352 _serde::__private::None => {
353 return _serde::__private::Err(
354 <__A::Error as _serde::de::Error>::missing_field(
355 "vertexBufferIndex",
356 ),
357 );
358 }
359 };
360 let m_elementIndex = match m_elementIndex {
361 _serde::__private::Some(__field) => __field,
362 _serde::__private::None => {
363 return _serde::__private::Err(
364 <__A::Error as _serde::de::Error>::missing_field(
365 "elementIndex",
366 ),
367 );
368 }
369 };
370 let m_lockedBufferIndex = match m_lockedBufferIndex {
371 _serde::__private::Some(__field) => __field,
372 _serde::__private::None => {
373 return _serde::__private::Err(
374 <__A::Error as _serde::de::Error>::missing_field(
375 "lockedBufferIndex",
376 ),
377 );
378 }
379 };
380 let m_vertexFormatIndex = match m_vertexFormatIndex {
381 _serde::__private::Some(__field) => __field,
382 _serde::__private::None => {
383 return _serde::__private::Err(
384 <__A::Error as _serde::de::Error>::missing_field(
385 "vertexFormatIndex",
386 ),
387 );
388 }
389 };
390 let m_lockFlags = match m_lockFlags {
391 _serde::__private::Some(__field) => __field,
392 _serde::__private::None => {
393 return _serde::__private::Err(
394 <__A::Error as _serde::de::Error>::missing_field(
395 "lockFlags",
396 ),
397 );
398 }
399 };
400 let m_outputBufferIndex = match m_outputBufferIndex {
401 _serde::__private::Some(__field) => __field,
402 _serde::__private::None => {
403 return _serde::__private::Err(
404 <__A::Error as _serde::de::Error>::missing_field(
405 "outputBufferIndex",
406 ),
407 );
408 }
409 };
410 let m_emulatedIndex = match m_emulatedIndex {
411 _serde::__private::Some(__field) => __field,
412 _serde::__private::None => {
413 return _serde::__private::Err(
414 <__A::Error as _serde::de::Error>::missing_field(
415 "emulatedIndex",
416 ),
417 );
418 }
419 };
420 _serde::__private::Ok(hkMultipleVertexBufferLockedElement {
421 __ptr,
422 m_vertexBufferIndex,
423 m_elementIndex,
424 m_lockedBufferIndex,
425 m_vertexFormatIndex,
426 m_lockFlags,
427 m_outputBufferIndex,
428 m_emulatedIndex,
429 })
430 }
431 #[allow(clippy::manual_unwrap_or_default)]
432 fn visit_struct<__A>(
433 self,
434 mut __map: __A,
435 ) -> _serde::__private::Result<Self::Value, __A::Error>
436 where
437 __A: _serde::de::MapAccess<'de>,
438 {
439 let mut m_vertexBufferIndex: _serde::__private::Option<u8> = _serde::__private::None;
440 let mut m_elementIndex: _serde::__private::Option<u8> = _serde::__private::None;
441 let mut m_lockedBufferIndex: _serde::__private::Option<u8> = _serde::__private::None;
442 let mut m_vertexFormatIndex: _serde::__private::Option<u8> = _serde::__private::None;
443 let mut m_lockFlags: _serde::__private::Option<u8> = _serde::__private::None;
444 let mut m_outputBufferIndex: _serde::__private::Option<u8> = _serde::__private::None;
445 let mut m_emulatedIndex: _serde::__private::Option<i8> = _serde::__private::None;
446 while let _serde::__private::Some(__key) = {
447 __A::next_key::<__Field>(&mut __map)?
448 } {
449 match __key {
450 __Field::m_vertexBufferIndex => {
451 #[cfg(
452 any(feature = "strict", feature = "ignore_duplicates")
453 )]
454 if _serde::__private::Option::is_some(
455 &m_vertexBufferIndex,
456 ) {
457 #[cfg(feature = "ignore_duplicates")]
458 {
459 __A::skip_value(&mut __map)?;
460 continue;
461 }
462 #[cfg(feature = "strict")]
463 return _serde::__private::Err(
464 <__A::Error as _serde::de::Error>::duplicate_field(
465 "vertexBufferIndex",
466 ),
467 );
468 }
469 m_vertexBufferIndex = _serde::__private::Some(
470 match __A::next_value::<u8>(&mut __map) {
471 _serde::__private::Ok(__val) => __val,
472 _serde::__private::Err(__err) => {
473 return _serde::__private::Err(__err);
474 }
475 },
476 );
477 }
478 __Field::m_elementIndex => {
479 #[cfg(
480 any(feature = "strict", feature = "ignore_duplicates")
481 )]
482 if _serde::__private::Option::is_some(&m_elementIndex) {
483 #[cfg(feature = "ignore_duplicates")]
484 {
485 __A::skip_value(&mut __map)?;
486 continue;
487 }
488 #[cfg(feature = "strict")]
489 return _serde::__private::Err(
490 <__A::Error as _serde::de::Error>::duplicate_field(
491 "elementIndex",
492 ),
493 );
494 }
495 m_elementIndex = _serde::__private::Some(
496 match __A::next_value::<u8>(&mut __map) {
497 _serde::__private::Ok(__val) => __val,
498 _serde::__private::Err(__err) => {
499 return _serde::__private::Err(__err);
500 }
501 },
502 );
503 }
504 __Field::m_lockedBufferIndex => {
505 #[cfg(
506 any(feature = "strict", feature = "ignore_duplicates")
507 )]
508 if _serde::__private::Option::is_some(
509 &m_lockedBufferIndex,
510 ) {
511 #[cfg(feature = "ignore_duplicates")]
512 {
513 __A::skip_value(&mut __map)?;
514 continue;
515 }
516 #[cfg(feature = "strict")]
517 return _serde::__private::Err(
518 <__A::Error as _serde::de::Error>::duplicate_field(
519 "lockedBufferIndex",
520 ),
521 );
522 }
523 m_lockedBufferIndex = _serde::__private::Some(
524 match __A::next_value::<u8>(&mut __map) {
525 _serde::__private::Ok(__val) => __val,
526 _serde::__private::Err(__err) => {
527 return _serde::__private::Err(__err);
528 }
529 },
530 );
531 }
532 __Field::m_vertexFormatIndex => {
533 #[cfg(
534 any(feature = "strict", feature = "ignore_duplicates")
535 )]
536 if _serde::__private::Option::is_some(
537 &m_vertexFormatIndex,
538 ) {
539 #[cfg(feature = "ignore_duplicates")]
540 {
541 __A::skip_value(&mut __map)?;
542 continue;
543 }
544 #[cfg(feature = "strict")]
545 return _serde::__private::Err(
546 <__A::Error as _serde::de::Error>::duplicate_field(
547 "vertexFormatIndex",
548 ),
549 );
550 }
551 m_vertexFormatIndex = _serde::__private::Some(
552 match __A::next_value::<u8>(&mut __map) {
553 _serde::__private::Ok(__val) => __val,
554 _serde::__private::Err(__err) => {
555 return _serde::__private::Err(__err);
556 }
557 },
558 );
559 }
560 __Field::m_lockFlags => {
561 #[cfg(
562 any(feature = "strict", feature = "ignore_duplicates")
563 )]
564 if _serde::__private::Option::is_some(&m_lockFlags) {
565 #[cfg(feature = "ignore_duplicates")]
566 {
567 __A::skip_value(&mut __map)?;
568 continue;
569 }
570 #[cfg(feature = "strict")]
571 return _serde::__private::Err(
572 <__A::Error as _serde::de::Error>::duplicate_field(
573 "lockFlags",
574 ),
575 );
576 }
577 m_lockFlags = _serde::__private::Some(
578 match __A::next_value::<u8>(&mut __map) {
579 _serde::__private::Ok(__val) => __val,
580 _serde::__private::Err(__err) => {
581 return _serde::__private::Err(__err);
582 }
583 },
584 );
585 }
586 __Field::m_outputBufferIndex => {
587 #[cfg(
588 any(feature = "strict", feature = "ignore_duplicates")
589 )]
590 if _serde::__private::Option::is_some(
591 &m_outputBufferIndex,
592 ) {
593 #[cfg(feature = "ignore_duplicates")]
594 {
595 __A::skip_value(&mut __map)?;
596 continue;
597 }
598 #[cfg(feature = "strict")]
599 return _serde::__private::Err(
600 <__A::Error as _serde::de::Error>::duplicate_field(
601 "outputBufferIndex",
602 ),
603 );
604 }
605 m_outputBufferIndex = _serde::__private::Some(
606 match __A::next_value::<u8>(&mut __map) {
607 _serde::__private::Ok(__val) => __val,
608 _serde::__private::Err(__err) => {
609 return _serde::__private::Err(__err);
610 }
611 },
612 );
613 }
614 __Field::m_emulatedIndex => {
615 #[cfg(
616 any(feature = "strict", feature = "ignore_duplicates")
617 )]
618 if _serde::__private::Option::is_some(&m_emulatedIndex) {
619 #[cfg(feature = "ignore_duplicates")]
620 {
621 __A::skip_value(&mut __map)?;
622 continue;
623 }
624 #[cfg(feature = "strict")]
625 return _serde::__private::Err(
626 <__A::Error as _serde::de::Error>::duplicate_field(
627 "emulatedIndex",
628 ),
629 );
630 }
631 m_emulatedIndex = _serde::__private::Some(
632 match __A::next_value::<i8>(&mut __map) {
633 _serde::__private::Ok(__val) => __val,
634 _serde::__private::Err(__err) => {
635 return _serde::__private::Err(__err);
636 }
637 },
638 );
639 }
640 _ => __A::skip_value(&mut __map)?,
641 }
642 }
643 let m_vertexBufferIndex = match m_vertexBufferIndex {
644 _serde::__private::Some(__field) => __field,
645 _serde::__private::None => {
646 #[cfg(feature = "strict")]
647 return _serde::__private::Err(
648 <__A::Error as _serde::de::Error>::missing_field(
649 "vertexBufferIndex",
650 ),
651 );
652 #[cfg(not(feature = "strict"))] Default::default()
653 }
654 };
655 let m_elementIndex = match m_elementIndex {
656 _serde::__private::Some(__field) => __field,
657 _serde::__private::None => {
658 #[cfg(feature = "strict")]
659 return _serde::__private::Err(
660 <__A::Error as _serde::de::Error>::missing_field(
661 "elementIndex",
662 ),
663 );
664 #[cfg(not(feature = "strict"))] Default::default()
665 }
666 };
667 let m_lockedBufferIndex = match m_lockedBufferIndex {
668 _serde::__private::Some(__field) => __field,
669 _serde::__private::None => {
670 #[cfg(feature = "strict")]
671 return _serde::__private::Err(
672 <__A::Error as _serde::de::Error>::missing_field(
673 "lockedBufferIndex",
674 ),
675 );
676 #[cfg(not(feature = "strict"))] Default::default()
677 }
678 };
679 let m_vertexFormatIndex = match m_vertexFormatIndex {
680 _serde::__private::Some(__field) => __field,
681 _serde::__private::None => {
682 #[cfg(feature = "strict")]
683 return _serde::__private::Err(
684 <__A::Error as _serde::de::Error>::missing_field(
685 "vertexFormatIndex",
686 ),
687 );
688 #[cfg(not(feature = "strict"))] Default::default()
689 }
690 };
691 let m_lockFlags = match m_lockFlags {
692 _serde::__private::Some(__field) => __field,
693 _serde::__private::None => {
694 #[cfg(feature = "strict")]
695 return _serde::__private::Err(
696 <__A::Error as _serde::de::Error>::missing_field(
697 "lockFlags",
698 ),
699 );
700 #[cfg(not(feature = "strict"))] Default::default()
701 }
702 };
703 let m_outputBufferIndex = match m_outputBufferIndex {
704 _serde::__private::Some(__field) => __field,
705 _serde::__private::None => {
706 #[cfg(feature = "strict")]
707 return _serde::__private::Err(
708 <__A::Error as _serde::de::Error>::missing_field(
709 "outputBufferIndex",
710 ),
711 );
712 #[cfg(not(feature = "strict"))] Default::default()
713 }
714 };
715 let m_emulatedIndex = match m_emulatedIndex {
716 _serde::__private::Some(__field) => __field,
717 _serde::__private::None => {
718 #[cfg(feature = "strict")]
719 return _serde::__private::Err(
720 <__A::Error as _serde::de::Error>::missing_field(
721 "emulatedIndex",
722 ),
723 );
724 #[cfg(not(feature = "strict"))] Default::default()
725 }
726 };
727 let __ptr = __A::class_ptr(&mut __map);
728 _serde::__private::Ok(hkMultipleVertexBufferLockedElement {
729 __ptr,
730 m_vertexBufferIndex,
731 m_elementIndex,
732 m_lockedBufferIndex,
733 m_vertexFormatIndex,
734 m_lockFlags,
735 m_outputBufferIndex,
736 m_emulatedIndex,
737 })
738 }
739 }
740 const FIELDS: &[&str] = &[
741 "vertexBufferIndex",
742 "elementIndex",
743 "lockedBufferIndex",
744 "vertexFormatIndex",
745 "lockFlags",
746 "outputBufferIndex",
747 "emulatedIndex",
748 ];
749 _serde::Deserializer::deserialize_struct(
750 deserializer,
751 "hkMultipleVertexBufferLockedElement",
752 FIELDS,
753 __hkMultipleVertexBufferLockedElementVisitor {
754 marker: _serde::__private::PhantomData::<
755 hkMultipleVertexBufferLockedElement,
756 >,
757 lifetime: _serde::__private::PhantomData,
758 },
759 )
760 }
761 }
762};