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 hkxMeshSection {
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: hkReferencedObject,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "vertexBuffer"))]
35 #[cfg_attr(feature = "serde", serde(rename = "vertexBuffer"))]
36 pub m_vertexBuffer: Pointer,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "indexBuffers"))]
42 #[cfg_attr(feature = "serde", serde(rename = "indexBuffers"))]
43 pub m_indexBuffers: Vec<Pointer>,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "material"))]
49 #[cfg_attr(feature = "serde", serde(rename = "material"))]
50 pub m_material: Pointer,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "userChannels"))]
56 #[cfg_attr(feature = "serde", serde(rename = "userChannels"))]
57 pub m_userChannels: Vec<Pointer>,
58}
59const _: () = {
60 use havok_serde as _serde;
61 impl _serde::HavokClass for hkxMeshSection {
62 #[inline]
63 fn name(&self) -> &'static str {
64 "hkxMeshSection"
65 }
66 #[inline]
67 fn signature(&self) -> _serde::__private::Signature {
68 _serde::__private::Signature::new(0xe2286cf8)
69 }
70 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
71 fn deps_indexes(&self) -> Vec<usize> {
72 let mut v = Vec::new();
73 v.push(self.m_vertexBuffer.get());
74 v.extend(self.m_indexBuffers.iter().map(|ptr| ptr.get()));
75 v.push(self.m_material.get());
76 v.extend(self.m_userChannels.iter().map(|ptr| ptr.get()));
77 v
78 }
79 }
80 impl _serde::Serialize for hkxMeshSection {
81 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
82 where
83 S: _serde::ser::Serializer,
84 {
85 let class_meta = self
86 .__ptr
87 .map(|name| (name, _serde::__private::Signature::new(0xe2286cf8)));
88 let mut serializer = __serializer
89 .serialize_struct("hkxMeshSection", class_meta, (40u64, 64u64))?;
90 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
91 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
92 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
93 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
94 serializer.serialize_field("vertexBuffer", &self.m_vertexBuffer)?;
95 serializer
96 .serialize_array_field(
97 "indexBuffers",
98 &self.m_indexBuffers,
99 TypeSize::NonPtr,
100 )?;
101 serializer.serialize_field("material", &self.m_material)?;
102 serializer
103 .serialize_array_field(
104 "userChannels",
105 &self.m_userChannels,
106 TypeSize::NonPtr,
107 )?;
108 serializer.end()
109 }
110 }
111};
112#[doc(hidden)]
113#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
114const _: () = {
115 use havok_serde as _serde;
116 #[automatically_derived]
117 impl<'de> _serde::Deserialize<'de> for hkxMeshSection {
118 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
119 where
120 __D: _serde::Deserializer<'de>,
121 {
122 #[allow(non_camel_case_types)]
123 enum __Field {
124 m_vertexBuffer,
125 m_indexBuffers,
126 m_material,
127 m_userChannels,
128 __ignore,
129 }
130 struct __FieldVisitor;
131 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
132 type Value = __Field;
133 fn expecting(
134 &self,
135 __formatter: &mut core::fmt::Formatter,
136 ) -> core::fmt::Result {
137 core::fmt::Formatter::write_str(__formatter, "field identifier")
138 }
139 #[allow(clippy::match_single_binding)]
141 #[allow(clippy::reversed_empty_ranges)]
142 #[allow(clippy::single_match)]
143 fn visit_key<__E>(
144 self,
145 __value: &str,
146 ) -> core::result::Result<Self::Value, __E>
147 where
148 __E: _serde::de::Error,
149 {
150 match __value {
151 "vertexBuffer" => Ok(__Field::m_vertexBuffer),
152 "indexBuffers" => Ok(__Field::m_indexBuffers),
153 "material" => Ok(__Field::m_material),
154 "userChannels" => Ok(__Field::m_userChannels),
155 _ => Ok(__Field::__ignore),
156 }
157 }
158 }
159 impl<'de> _serde::Deserialize<'de> for __Field {
160 #[inline]
161 fn deserialize<__D>(
162 __deserializer: __D,
163 ) -> core::result::Result<Self, __D::Error>
164 where
165 __D: _serde::Deserializer<'de>,
166 {
167 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
168 }
169 }
170 struct __hkxMeshSectionVisitor<'de> {
171 marker: _serde::__private::PhantomData<hkxMeshSection>,
172 lifetime: _serde::__private::PhantomData<&'de ()>,
173 }
174 #[allow(clippy::match_single_binding)]
175 #[allow(clippy::reversed_empty_ranges)]
176 #[allow(clippy::single_match)]
177 impl<'de> _serde::de::Visitor<'de> for __hkxMeshSectionVisitor<'de> {
178 type Value = hkxMeshSection;
179 fn expecting(
180 &self,
181 __formatter: &mut core::fmt::Formatter,
182 ) -> core::fmt::Result {
183 core::fmt::Formatter::write_str(__formatter, "struct hkxMeshSection")
184 }
185 fn visit_struct_for_bytes<__A>(
186 self,
187 mut __map: __A,
188 ) -> _serde::__private::Result<Self::Value, __A::Error>
189 where
190 __A: _serde::de::MapAccess<'de>,
191 {
192 let __ptr = __A::class_ptr(&mut __map);
193 let parent = __A::parent_value(&mut __map)?;
194 let mut m_vertexBuffer: _serde::__private::Option<Pointer> = _serde::__private::None;
195 let mut m_indexBuffers: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
196 let mut m_material: _serde::__private::Option<Pointer> = _serde::__private::None;
197 let mut m_userChannels: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
198 for i in 0..4usize {
199 match i {
200 0usize => {
201 if _serde::__private::Option::is_some(&m_vertexBuffer) {
202 return _serde::__private::Err(
203 <__A::Error as _serde::de::Error>::duplicate_field(
204 "vertexBuffer",
205 ),
206 );
207 }
208 m_vertexBuffer = _serde::__private::Some(
209 match __A::next_value::<Pointer>(&mut __map) {
210 _serde::__private::Ok(__val) => __val,
211 _serde::__private::Err(__err) => {
212 return _serde::__private::Err(__err);
213 }
214 },
215 );
216 }
217 1usize => {
218 if _serde::__private::Option::is_some(&m_indexBuffers) {
219 return _serde::__private::Err(
220 <__A::Error as _serde::de::Error>::duplicate_field(
221 "indexBuffers",
222 ),
223 );
224 }
225 m_indexBuffers = _serde::__private::Some(
226 match __A::next_value::<Vec<Pointer>>(&mut __map) {
227 _serde::__private::Ok(__val) => __val,
228 _serde::__private::Err(__err) => {
229 return _serde::__private::Err(__err);
230 }
231 },
232 );
233 }
234 2usize => {
235 if _serde::__private::Option::is_some(&m_material) {
236 return _serde::__private::Err(
237 <__A::Error as _serde::de::Error>::duplicate_field(
238 "material",
239 ),
240 );
241 }
242 m_material = _serde::__private::Some(
243 match __A::next_value::<Pointer>(&mut __map) {
244 _serde::__private::Ok(__val) => __val,
245 _serde::__private::Err(__err) => {
246 return _serde::__private::Err(__err);
247 }
248 },
249 );
250 }
251 3usize => {
252 if _serde::__private::Option::is_some(&m_userChannels) {
253 return _serde::__private::Err(
254 <__A::Error as _serde::de::Error>::duplicate_field(
255 "userChannels",
256 ),
257 );
258 }
259 m_userChannels = _serde::__private::Some(
260 match __A::next_value::<Vec<Pointer>>(&mut __map) {
261 _serde::__private::Ok(__val) => __val,
262 _serde::__private::Err(__err) => {
263 return _serde::__private::Err(__err);
264 }
265 },
266 );
267 }
268 _ => {}
269 }
270 }
271 let m_vertexBuffer = match m_vertexBuffer {
272 _serde::__private::Some(__field) => __field,
273 _serde::__private::None => {
274 return _serde::__private::Err(
275 <__A::Error as _serde::de::Error>::missing_field(
276 "vertexBuffer",
277 ),
278 );
279 }
280 };
281 let m_indexBuffers = match m_indexBuffers {
282 _serde::__private::Some(__field) => __field,
283 _serde::__private::None => {
284 return _serde::__private::Err(
285 <__A::Error as _serde::de::Error>::missing_field(
286 "indexBuffers",
287 ),
288 );
289 }
290 };
291 let m_material = match m_material {
292 _serde::__private::Some(__field) => __field,
293 _serde::__private::None => {
294 return _serde::__private::Err(
295 <__A::Error as _serde::de::Error>::missing_field("material"),
296 );
297 }
298 };
299 let m_userChannels = match m_userChannels {
300 _serde::__private::Some(__field) => __field,
301 _serde::__private::None => {
302 return _serde::__private::Err(
303 <__A::Error as _serde::de::Error>::missing_field(
304 "userChannels",
305 ),
306 );
307 }
308 };
309 _serde::__private::Ok(hkxMeshSection {
310 __ptr,
311 parent,
312 m_vertexBuffer,
313 m_indexBuffers,
314 m_material,
315 m_userChannels,
316 })
317 }
318 #[allow(clippy::manual_unwrap_or_default)]
319 fn visit_struct<__A>(
320 self,
321 mut __map: __A,
322 ) -> _serde::__private::Result<Self::Value, __A::Error>
323 where
324 __A: _serde::de::MapAccess<'de>,
325 {
326 let mut m_vertexBuffer: _serde::__private::Option<Pointer> = _serde::__private::None;
327 let mut m_indexBuffers: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
328 let mut m_material: _serde::__private::Option<Pointer> = _serde::__private::None;
329 let mut m_userChannels: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
330 while let _serde::__private::Some(__key) = {
331 __A::next_key::<__Field>(&mut __map)?
332 } {
333 match __key {
334 __Field::m_vertexBuffer => {
335 #[cfg(
336 any(feature = "strict", feature = "ignore_duplicates")
337 )]
338 if _serde::__private::Option::is_some(&m_vertexBuffer) {
339 #[cfg(feature = "ignore_duplicates")]
340 {
341 __A::skip_value(&mut __map)?;
342 continue;
343 }
344 #[cfg(feature = "strict")]
345 return _serde::__private::Err(
346 <__A::Error as _serde::de::Error>::duplicate_field(
347 "vertexBuffer",
348 ),
349 );
350 }
351 m_vertexBuffer = _serde::__private::Some(
352 match __A::next_value::<Pointer>(&mut __map) {
353 _serde::__private::Ok(__val) => __val,
354 _serde::__private::Err(__err) => {
355 return _serde::__private::Err(__err);
356 }
357 },
358 );
359 }
360 __Field::m_indexBuffers => {
361 #[cfg(
362 any(feature = "strict", feature = "ignore_duplicates")
363 )]
364 if _serde::__private::Option::is_some(&m_indexBuffers) {
365 #[cfg(feature = "ignore_duplicates")]
366 {
367 __A::skip_value(&mut __map)?;
368 continue;
369 }
370 #[cfg(feature = "strict")]
371 return _serde::__private::Err(
372 <__A::Error as _serde::de::Error>::duplicate_field(
373 "indexBuffers",
374 ),
375 );
376 }
377 m_indexBuffers = _serde::__private::Some(
378 match __A::next_value::<Vec<Pointer>>(&mut __map) {
379 _serde::__private::Ok(__val) => __val,
380 _serde::__private::Err(__err) => {
381 return _serde::__private::Err(__err);
382 }
383 },
384 );
385 }
386 __Field::m_material => {
387 #[cfg(
388 any(feature = "strict", feature = "ignore_duplicates")
389 )]
390 if _serde::__private::Option::is_some(&m_material) {
391 #[cfg(feature = "ignore_duplicates")]
392 {
393 __A::skip_value(&mut __map)?;
394 continue;
395 }
396 #[cfg(feature = "strict")]
397 return _serde::__private::Err(
398 <__A::Error as _serde::de::Error>::duplicate_field(
399 "material",
400 ),
401 );
402 }
403 m_material = _serde::__private::Some(
404 match __A::next_value::<Pointer>(&mut __map) {
405 _serde::__private::Ok(__val) => __val,
406 _serde::__private::Err(__err) => {
407 return _serde::__private::Err(__err);
408 }
409 },
410 );
411 }
412 __Field::m_userChannels => {
413 #[cfg(
414 any(feature = "strict", feature = "ignore_duplicates")
415 )]
416 if _serde::__private::Option::is_some(&m_userChannels) {
417 #[cfg(feature = "ignore_duplicates")]
418 {
419 __A::skip_value(&mut __map)?;
420 continue;
421 }
422 #[cfg(feature = "strict")]
423 return _serde::__private::Err(
424 <__A::Error as _serde::de::Error>::duplicate_field(
425 "userChannels",
426 ),
427 );
428 }
429 m_userChannels = _serde::__private::Some(
430 match __A::next_value::<Vec<Pointer>>(&mut __map) {
431 _serde::__private::Ok(__val) => __val,
432 _serde::__private::Err(__err) => {
433 return _serde::__private::Err(__err);
434 }
435 },
436 );
437 }
438 _ => __A::skip_value(&mut __map)?,
439 }
440 }
441 let m_vertexBuffer = match m_vertexBuffer {
442 _serde::__private::Some(__field) => __field,
443 _serde::__private::None => {
444 #[cfg(feature = "strict")]
445 return _serde::__private::Err(
446 <__A::Error as _serde::de::Error>::missing_field(
447 "vertexBuffer",
448 ),
449 );
450 #[cfg(not(feature = "strict"))] Default::default()
451 }
452 };
453 let m_indexBuffers = match m_indexBuffers {
454 _serde::__private::Some(__field) => __field,
455 _serde::__private::None => {
456 #[cfg(feature = "strict")]
457 return _serde::__private::Err(
458 <__A::Error as _serde::de::Error>::missing_field(
459 "indexBuffers",
460 ),
461 );
462 #[cfg(not(feature = "strict"))] Default::default()
463 }
464 };
465 let m_material = match m_material {
466 _serde::__private::Some(__field) => __field,
467 _serde::__private::None => {
468 #[cfg(feature = "strict")]
469 return _serde::__private::Err(
470 <__A::Error as _serde::de::Error>::missing_field("material"),
471 );
472 #[cfg(not(feature = "strict"))] Default::default()
473 }
474 };
475 let m_userChannels = match m_userChannels {
476 _serde::__private::Some(__field) => __field,
477 _serde::__private::None => {
478 #[cfg(feature = "strict")]
479 return _serde::__private::Err(
480 <__A::Error as _serde::de::Error>::missing_field(
481 "userChannels",
482 ),
483 );
484 #[cfg(not(feature = "strict"))] Default::default()
485 }
486 };
487 let __ptr = None;
488 let parent = hkBaseObject { __ptr };
489 let parent = hkReferencedObject {
490 __ptr,
491 parent,
492 ..Default::default()
493 };
494 let __ptr = __A::class_ptr(&mut __map);
495 _serde::__private::Ok(hkxMeshSection {
496 __ptr,
497 parent,
498 m_vertexBuffer,
499 m_indexBuffers,
500 m_material,
501 m_userChannels,
502 })
503 }
504 }
505 const FIELDS: &[&str] = &[
506 "vertexBuffer",
507 "indexBuffers",
508 "material",
509 "userChannels",
510 ];
511 _serde::Deserializer::deserialize_struct(
512 deserializer,
513 "hkxMeshSection",
514 FIELDS,
515 __hkxMeshSectionVisitor {
516 marker: _serde::__private::PhantomData::<hkxMeshSection>,
517 lifetime: _serde::__private::PhantomData,
518 },
519 )
520 }
521 }
522};