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