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