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