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