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 hkpConvexVerticesConnectivity {
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 = "vertexIndices"))]
35 #[cfg_attr(feature = "serde", serde(rename = "vertexIndices"))]
36 pub m_vertexIndices: Vec<u16>,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "numVerticesPerFace"))]
42 #[cfg_attr(feature = "serde", serde(rename = "numVerticesPerFace"))]
43 pub m_numVerticesPerFace: Vec<u8>,
44}
45const _: () = {
46 use havok_serde as _serde;
47 impl _serde::HavokClass for hkpConvexVerticesConnectivity {
48 #[inline]
49 fn name(&self) -> &'static str {
50 "hkpConvexVerticesConnectivity"
51 }
52 #[inline]
53 fn signature(&self) -> _serde::__private::Signature {
54 _serde::__private::Signature::new(0x63d38e9c)
55 }
56 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
57 fn deps_indexes(&self) -> Vec<usize> {
58 let mut v = Vec::new();
59 v
60 }
61 }
62 impl _serde::Serialize for hkpConvexVerticesConnectivity {
63 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
64 where
65 S: _serde::ser::Serializer,
66 {
67 let class_meta = self
68 .__ptr
69 .map(|name| (name, _serde::__private::Signature::new(0x63d38e9c)));
70 let mut serializer = __serializer
71 .serialize_struct(
72 "hkpConvexVerticesConnectivity",
73 class_meta,
74 (32u64, 48u64),
75 )?;
76 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
77 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
78 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
79 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
80 serializer
81 .serialize_array_field(
82 "vertexIndices",
83 &self.m_vertexIndices,
84 TypeSize::NonPtr,
85 )?;
86 serializer
87 .serialize_array_field(
88 "numVerticesPerFace",
89 &self.m_numVerticesPerFace,
90 TypeSize::NonPtr,
91 )?;
92 serializer.end()
93 }
94 }
95};
96#[doc(hidden)]
97#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
98const _: () = {
99 use havok_serde as _serde;
100 #[automatically_derived]
101 impl<'de> _serde::Deserialize<'de> for hkpConvexVerticesConnectivity {
102 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
103 where
104 __D: _serde::Deserializer<'de>,
105 {
106 #[allow(non_camel_case_types)]
107 enum __Field {
108 m_vertexIndices,
109 m_numVerticesPerFace,
110 __ignore,
111 }
112 struct __FieldVisitor;
113 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
114 type Value = __Field;
115 fn expecting(
116 &self,
117 __formatter: &mut core::fmt::Formatter,
118 ) -> core::fmt::Result {
119 core::fmt::Formatter::write_str(__formatter, "field identifier")
120 }
121 #[allow(clippy::match_single_binding)]
123 #[allow(clippy::reversed_empty_ranges)]
124 #[allow(clippy::single_match)]
125 fn visit_key<__E>(
126 self,
127 __value: &str,
128 ) -> core::result::Result<Self::Value, __E>
129 where
130 __E: _serde::de::Error,
131 {
132 match __value {
133 "vertexIndices" => Ok(__Field::m_vertexIndices),
134 "numVerticesPerFace" => Ok(__Field::m_numVerticesPerFace),
135 _ => Ok(__Field::__ignore),
136 }
137 }
138 }
139 impl<'de> _serde::Deserialize<'de> for __Field {
140 #[inline]
141 fn deserialize<__D>(
142 __deserializer: __D,
143 ) -> core::result::Result<Self, __D::Error>
144 where
145 __D: _serde::Deserializer<'de>,
146 {
147 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
148 }
149 }
150 struct __hkpConvexVerticesConnectivityVisitor<'de> {
151 marker: _serde::__private::PhantomData<hkpConvexVerticesConnectivity>,
152 lifetime: _serde::__private::PhantomData<&'de ()>,
153 }
154 #[allow(clippy::match_single_binding)]
155 #[allow(clippy::reversed_empty_ranges)]
156 #[allow(clippy::single_match)]
157 impl<'de> _serde::de::Visitor<'de>
158 for __hkpConvexVerticesConnectivityVisitor<'de> {
159 type Value = hkpConvexVerticesConnectivity;
160 fn expecting(
161 &self,
162 __formatter: &mut core::fmt::Formatter,
163 ) -> core::fmt::Result {
164 core::fmt::Formatter::write_str(
165 __formatter,
166 "struct hkpConvexVerticesConnectivity",
167 )
168 }
169 fn visit_struct_for_bytes<__A>(
170 self,
171 mut __map: __A,
172 ) -> _serde::__private::Result<Self::Value, __A::Error>
173 where
174 __A: _serde::de::MapAccess<'de>,
175 {
176 let __ptr = __A::class_ptr(&mut __map);
177 let parent = __A::parent_value(&mut __map)?;
178 let mut m_vertexIndices: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
179 let mut m_numVerticesPerFace: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
180 for i in 0..2usize {
181 match i {
182 0usize => {
183 if _serde::__private::Option::is_some(&m_vertexIndices) {
184 return _serde::__private::Err(
185 <__A::Error as _serde::de::Error>::duplicate_field(
186 "vertexIndices",
187 ),
188 );
189 }
190 m_vertexIndices = _serde::__private::Some(
191 match __A::next_value::<Vec<u16>>(&mut __map) {
192 _serde::__private::Ok(__val) => __val,
193 _serde::__private::Err(__err) => {
194 return _serde::__private::Err(__err);
195 }
196 },
197 );
198 }
199 1usize => {
200 if _serde::__private::Option::is_some(
201 &m_numVerticesPerFace,
202 ) {
203 return _serde::__private::Err(
204 <__A::Error as _serde::de::Error>::duplicate_field(
205 "numVerticesPerFace",
206 ),
207 );
208 }
209 m_numVerticesPerFace = _serde::__private::Some(
210 match __A::next_value::<Vec<u8>>(&mut __map) {
211 _serde::__private::Ok(__val) => __val,
212 _serde::__private::Err(__err) => {
213 return _serde::__private::Err(__err);
214 }
215 },
216 );
217 }
218 _ => {}
219 }
220 }
221 let m_vertexIndices = match m_vertexIndices {
222 _serde::__private::Some(__field) => __field,
223 _serde::__private::None => {
224 return _serde::__private::Err(
225 <__A::Error as _serde::de::Error>::missing_field(
226 "vertexIndices",
227 ),
228 );
229 }
230 };
231 let m_numVerticesPerFace = match m_numVerticesPerFace {
232 _serde::__private::Some(__field) => __field,
233 _serde::__private::None => {
234 return _serde::__private::Err(
235 <__A::Error as _serde::de::Error>::missing_field(
236 "numVerticesPerFace",
237 ),
238 );
239 }
240 };
241 _serde::__private::Ok(hkpConvexVerticesConnectivity {
242 __ptr,
243 parent,
244 m_vertexIndices,
245 m_numVerticesPerFace,
246 })
247 }
248 #[allow(clippy::manual_unwrap_or_default)]
249 fn visit_struct<__A>(
250 self,
251 mut __map: __A,
252 ) -> _serde::__private::Result<Self::Value, __A::Error>
253 where
254 __A: _serde::de::MapAccess<'de>,
255 {
256 let mut m_vertexIndices: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
257 let mut m_numVerticesPerFace: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
258 while let _serde::__private::Some(__key) = {
259 __A::next_key::<__Field>(&mut __map)?
260 } {
261 match __key {
262 __Field::m_vertexIndices => {
263 #[cfg(
264 any(feature = "strict", feature = "ignore_duplicates")
265 )]
266 if _serde::__private::Option::is_some(&m_vertexIndices) {
267 #[cfg(feature = "ignore_duplicates")]
268 {
269 __A::skip_value(&mut __map)?;
270 continue;
271 }
272 #[cfg(feature = "strict")]
273 return _serde::__private::Err(
274 <__A::Error as _serde::de::Error>::duplicate_field(
275 "vertexIndices",
276 ),
277 );
278 }
279 m_vertexIndices = _serde::__private::Some(
280 match __A::next_value::<Vec<u16>>(&mut __map) {
281 _serde::__private::Ok(__val) => __val,
282 _serde::__private::Err(__err) => {
283 return _serde::__private::Err(__err);
284 }
285 },
286 );
287 }
288 __Field::m_numVerticesPerFace => {
289 #[cfg(
290 any(feature = "strict", feature = "ignore_duplicates")
291 )]
292 if _serde::__private::Option::is_some(
293 &m_numVerticesPerFace,
294 ) {
295 #[cfg(feature = "ignore_duplicates")]
296 {
297 __A::skip_value(&mut __map)?;
298 continue;
299 }
300 #[cfg(feature = "strict")]
301 return _serde::__private::Err(
302 <__A::Error as _serde::de::Error>::duplicate_field(
303 "numVerticesPerFace",
304 ),
305 );
306 }
307 m_numVerticesPerFace = _serde::__private::Some(
308 match __A::next_value::<Vec<u8>>(&mut __map) {
309 _serde::__private::Ok(__val) => __val,
310 _serde::__private::Err(__err) => {
311 return _serde::__private::Err(__err);
312 }
313 },
314 );
315 }
316 _ => __A::skip_value(&mut __map)?,
317 }
318 }
319 let m_vertexIndices = match m_vertexIndices {
320 _serde::__private::Some(__field) => __field,
321 _serde::__private::None => {
322 #[cfg(feature = "strict")]
323 return _serde::__private::Err(
324 <__A::Error as _serde::de::Error>::missing_field(
325 "vertexIndices",
326 ),
327 );
328 #[cfg(not(feature = "strict"))] Default::default()
329 }
330 };
331 let m_numVerticesPerFace = match m_numVerticesPerFace {
332 _serde::__private::Some(__field) => __field,
333 _serde::__private::None => {
334 #[cfg(feature = "strict")]
335 return _serde::__private::Err(
336 <__A::Error as _serde::de::Error>::missing_field(
337 "numVerticesPerFace",
338 ),
339 );
340 #[cfg(not(feature = "strict"))] Default::default()
341 }
342 };
343 let __ptr = None;
344 let parent = hkBaseObject { __ptr };
345 let parent = hkReferencedObject {
346 __ptr,
347 parent,
348 ..Default::default()
349 };
350 let __ptr = __A::class_ptr(&mut __map);
351 _serde::__private::Ok(hkpConvexVerticesConnectivity {
352 __ptr,
353 parent,
354 m_vertexIndices,
355 m_numVerticesPerFace,
356 })
357 }
358 }
359 const FIELDS: &[&str] = &["vertexIndices", "numVerticesPerFace"];
360 _serde::Deserializer::deserialize_struct(
361 deserializer,
362 "hkpConvexVerticesConnectivity",
363 FIELDS,
364 __hkpConvexVerticesConnectivityVisitor {
365 marker: _serde::__private::PhantomData::<
366 hkpConvexVerticesConnectivity,
367 >,
368 lifetime: _serde::__private::PhantomData,
369 },
370 )
371 }
372 }
373};