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