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