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