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