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 hkpStorageExtendedMeshShapeMaterial {
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: hkpMeshMaterial,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "restitution"))]
35 #[cfg_attr(feature = "serde", serde(rename = "restitution"))]
36 pub m_restitution: f16,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "friction"))]
42 #[cfg_attr(feature = "serde", serde(rename = "friction"))]
43 pub m_friction: f16,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "userData"))]
49 #[cfg_attr(feature = "serde", serde(rename = "userData"))]
50 pub m_userData: Ulong,
51}
52const _: () = {
53 use havok_serde as _serde;
54 impl _serde::HavokClass for hkpStorageExtendedMeshShapeMaterial {
55 #[inline]
56 fn name(&self) -> &'static str {
57 "hkpStorageExtendedMeshShapeMaterial"
58 }
59 #[inline]
60 fn signature(&self) -> _serde::__private::Signature {
61 _serde::__private::Signature::new(0x2ca3e906)
62 }
63 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
64 fn deps_indexes(&self) -> Vec<usize> {
65 let mut v = Vec::new();
66 v
67 }
68 }
69 impl _serde::Serialize for hkpStorageExtendedMeshShapeMaterial {
70 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
71 where
72 S: _serde::ser::Serializer,
73 {
74 let class_meta = self
75 .__ptr
76 .map(|name| (name, _serde::__private::Signature::new(0x2ca3e906)));
77 let mut serializer = __serializer
78 .serialize_struct(
79 "hkpStorageExtendedMeshShapeMaterial",
80 class_meta,
81 (12u64, 16u64),
82 )?;
83 serializer.serialize_field("filterInfo", &self.parent.m_filterInfo)?;
84 serializer.serialize_field("restitution", &self.m_restitution)?;
85 serializer.serialize_field("friction", &self.m_friction)?;
86 serializer.serialize_field("userData", &self.m_userData)?;
87 serializer.end()
88 }
89 }
90};
91#[doc(hidden)]
92#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
93const _: () = {
94 use havok_serde as _serde;
95 #[automatically_derived]
96 impl<'de> _serde::Deserialize<'de> for hkpStorageExtendedMeshShapeMaterial {
97 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
98 where
99 __D: _serde::Deserializer<'de>,
100 {
101 #[allow(non_camel_case_types)]
102 enum __Field {
103 m_filterInfo,
104 m_restitution,
105 m_friction,
106 m_userData,
107 __ignore,
108 }
109 struct __FieldVisitor;
110 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
111 type Value = __Field;
112 fn expecting(
113 &self,
114 __formatter: &mut core::fmt::Formatter,
115 ) -> core::fmt::Result {
116 core::fmt::Formatter::write_str(__formatter, "field identifier")
117 }
118 #[allow(clippy::match_single_binding)]
120 #[allow(clippy::reversed_empty_ranges)]
121 #[allow(clippy::single_match)]
122 fn visit_key<__E>(
123 self,
124 __value: &str,
125 ) -> core::result::Result<Self::Value, __E>
126 where
127 __E: _serde::de::Error,
128 {
129 match __value {
130 "filterInfo" => Ok(__Field::m_filterInfo),
131 "restitution" => Ok(__Field::m_restitution),
132 "friction" => Ok(__Field::m_friction),
133 "userData" => Ok(__Field::m_userData),
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 __hkpStorageExtendedMeshShapeMaterialVisitor<'de> {
150 marker: _serde::__private::PhantomData<
151 hkpStorageExtendedMeshShapeMaterial,
152 >,
153 lifetime: _serde::__private::PhantomData<&'de ()>,
154 }
155 #[allow(clippy::match_single_binding)]
156 #[allow(clippy::reversed_empty_ranges)]
157 #[allow(clippy::single_match)]
158 impl<'de> _serde::de::Visitor<'de>
159 for __hkpStorageExtendedMeshShapeMaterialVisitor<'de> {
160 type Value = hkpStorageExtendedMeshShapeMaterial;
161 fn expecting(
162 &self,
163 __formatter: &mut core::fmt::Formatter,
164 ) -> core::fmt::Result {
165 core::fmt::Formatter::write_str(
166 __formatter,
167 "struct hkpStorageExtendedMeshShapeMaterial",
168 )
169 }
170 fn visit_struct_for_bytes<__A>(
171 self,
172 mut __map: __A,
173 ) -> _serde::__private::Result<Self::Value, __A::Error>
174 where
175 __A: _serde::de::MapAccess<'de>,
176 {
177 let __ptr = __A::class_ptr(&mut __map);
178 let parent = __A::parent_value(&mut __map)?;
179 let mut m_restitution: _serde::__private::Option<f16> = _serde::__private::None;
180 let mut m_friction: _serde::__private::Option<f16> = _serde::__private::None;
181 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
182 for i in 0..3usize {
183 match i {
184 0usize => {
185 if _serde::__private::Option::is_some(&m_restitution) {
186 return _serde::__private::Err(
187 <__A::Error as _serde::de::Error>::duplicate_field(
188 "restitution",
189 ),
190 );
191 }
192 m_restitution = _serde::__private::Some(
193 match __A::next_value::<f16>(&mut __map) {
194 _serde::__private::Ok(__val) => __val,
195 _serde::__private::Err(__err) => {
196 return _serde::__private::Err(__err);
197 }
198 },
199 );
200 }
201 1usize => {
202 if _serde::__private::Option::is_some(&m_friction) {
203 return _serde::__private::Err(
204 <__A::Error as _serde::de::Error>::duplicate_field(
205 "friction",
206 ),
207 );
208 }
209 m_friction = _serde::__private::Some(
210 match __A::next_value::<f16>(&mut __map) {
211 _serde::__private::Ok(__val) => __val,
212 _serde::__private::Err(__err) => {
213 return _serde::__private::Err(__err);
214 }
215 },
216 );
217 }
218 2usize => {
219 if _serde::__private::Option::is_some(&m_userData) {
220 return _serde::__private::Err(
221 <__A::Error as _serde::de::Error>::duplicate_field(
222 "userData",
223 ),
224 );
225 }
226 m_userData = _serde::__private::Some(
227 match __A::next_value::<Ulong>(&mut __map) {
228 _serde::__private::Ok(__val) => __val,
229 _serde::__private::Err(__err) => {
230 return _serde::__private::Err(__err);
231 }
232 },
233 );
234 }
235 _ => {}
236 }
237 }
238 let m_restitution = match m_restitution {
239 _serde::__private::Some(__field) => __field,
240 _serde::__private::None => {
241 return _serde::__private::Err(
242 <__A::Error as _serde::de::Error>::missing_field(
243 "restitution",
244 ),
245 );
246 }
247 };
248 let m_friction = match m_friction {
249 _serde::__private::Some(__field) => __field,
250 _serde::__private::None => {
251 return _serde::__private::Err(
252 <__A::Error as _serde::de::Error>::missing_field("friction"),
253 );
254 }
255 };
256 let m_userData = match m_userData {
257 _serde::__private::Some(__field) => __field,
258 _serde::__private::None => {
259 return _serde::__private::Err(
260 <__A::Error as _serde::de::Error>::missing_field("userData"),
261 );
262 }
263 };
264 _serde::__private::Ok(hkpStorageExtendedMeshShapeMaterial {
265 __ptr,
266 parent,
267 m_restitution,
268 m_friction,
269 m_userData,
270 })
271 }
272 #[allow(clippy::manual_unwrap_or_default)]
273 fn visit_struct<__A>(
274 self,
275 mut __map: __A,
276 ) -> _serde::__private::Result<Self::Value, __A::Error>
277 where
278 __A: _serde::de::MapAccess<'de>,
279 {
280 let mut m_filterInfo: _serde::__private::Option<u32> = _serde::__private::None;
281 let mut m_restitution: _serde::__private::Option<f16> = _serde::__private::None;
282 let mut m_friction: _serde::__private::Option<f16> = _serde::__private::None;
283 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
284 while let _serde::__private::Some(__key) = {
285 __A::next_key::<__Field>(&mut __map)?
286 } {
287 match __key {
288 __Field::m_filterInfo => {
289 #[cfg(
290 any(feature = "strict", feature = "ignore_duplicates")
291 )]
292 if _serde::__private::Option::is_some(&m_filterInfo) {
293 #[cfg(feature = "ignore_duplicates")]
294 {
295 __A::skip_value(&mut __map)?;
296 continue;
297 }
298 #[cfg(feature = "strict")]
299 return _serde::__private::Err(
300 <__A::Error as _serde::de::Error>::duplicate_field(
301 "filterInfo",
302 ),
303 );
304 }
305 m_filterInfo = _serde::__private::Some(
306 match __A::next_value::<u32>(&mut __map) {
307 _serde::__private::Ok(__val) => __val,
308 _serde::__private::Err(__err) => {
309 return _serde::__private::Err(__err);
310 }
311 },
312 );
313 }
314 __Field::m_restitution => {
315 #[cfg(
316 any(feature = "strict", feature = "ignore_duplicates")
317 )]
318 if _serde::__private::Option::is_some(&m_restitution) {
319 #[cfg(feature = "ignore_duplicates")]
320 {
321 __A::skip_value(&mut __map)?;
322 continue;
323 }
324 #[cfg(feature = "strict")]
325 return _serde::__private::Err(
326 <__A::Error as _serde::de::Error>::duplicate_field(
327 "restitution",
328 ),
329 );
330 }
331 m_restitution = _serde::__private::Some(
332 match __A::next_value::<f16>(&mut __map) {
333 _serde::__private::Ok(__val) => __val,
334 _serde::__private::Err(__err) => {
335 return _serde::__private::Err(__err);
336 }
337 },
338 );
339 }
340 __Field::m_friction => {
341 #[cfg(
342 any(feature = "strict", feature = "ignore_duplicates")
343 )]
344 if _serde::__private::Option::is_some(&m_friction) {
345 #[cfg(feature = "ignore_duplicates")]
346 {
347 __A::skip_value(&mut __map)?;
348 continue;
349 }
350 #[cfg(feature = "strict")]
351 return _serde::__private::Err(
352 <__A::Error as _serde::de::Error>::duplicate_field(
353 "friction",
354 ),
355 );
356 }
357 m_friction = _serde::__private::Some(
358 match __A::next_value::<f16>(&mut __map) {
359 _serde::__private::Ok(__val) => __val,
360 _serde::__private::Err(__err) => {
361 return _serde::__private::Err(__err);
362 }
363 },
364 );
365 }
366 __Field::m_userData => {
367 #[cfg(
368 any(feature = "strict", feature = "ignore_duplicates")
369 )]
370 if _serde::__private::Option::is_some(&m_userData) {
371 #[cfg(feature = "ignore_duplicates")]
372 {
373 __A::skip_value(&mut __map)?;
374 continue;
375 }
376 #[cfg(feature = "strict")]
377 return _serde::__private::Err(
378 <__A::Error as _serde::de::Error>::duplicate_field(
379 "userData",
380 ),
381 );
382 }
383 m_userData = _serde::__private::Some(
384 match __A::next_value::<Ulong>(&mut __map) {
385 _serde::__private::Ok(__val) => __val,
386 _serde::__private::Err(__err) => {
387 return _serde::__private::Err(__err);
388 }
389 },
390 );
391 }
392 _ => __A::skip_value(&mut __map)?,
393 }
394 }
395 let m_filterInfo = match m_filterInfo {
396 _serde::__private::Some(__field) => __field,
397 _serde::__private::None => {
398 #[cfg(feature = "strict")]
399 return _serde::__private::Err(
400 <__A::Error as _serde::de::Error>::missing_field(
401 "filterInfo",
402 ),
403 );
404 #[cfg(not(feature = "strict"))] Default::default()
405 }
406 };
407 let m_restitution = match m_restitution {
408 _serde::__private::Some(__field) => __field,
409 _serde::__private::None => {
410 #[cfg(feature = "strict")]
411 return _serde::__private::Err(
412 <__A::Error as _serde::de::Error>::missing_field(
413 "restitution",
414 ),
415 );
416 #[cfg(not(feature = "strict"))] Default::default()
417 }
418 };
419 let m_friction = match m_friction {
420 _serde::__private::Some(__field) => __field,
421 _serde::__private::None => {
422 #[cfg(feature = "strict")]
423 return _serde::__private::Err(
424 <__A::Error as _serde::de::Error>::missing_field("friction"),
425 );
426 #[cfg(not(feature = "strict"))] Default::default()
427 }
428 };
429 let m_userData = match m_userData {
430 _serde::__private::Some(__field) => __field,
431 _serde::__private::None => {
432 #[cfg(feature = "strict")]
433 return _serde::__private::Err(
434 <__A::Error as _serde::de::Error>::missing_field("userData"),
435 );
436 #[cfg(not(feature = "strict"))] Default::default()
437 }
438 };
439 let __ptr = None;
440 let parent = hkpMeshMaterial {
441 __ptr,
442 m_filterInfo,
443 };
444 let __ptr = __A::class_ptr(&mut __map);
445 _serde::__private::Ok(hkpStorageExtendedMeshShapeMaterial {
446 __ptr,
447 parent,
448 m_restitution,
449 m_friction,
450 m_userData,
451 })
452 }
453 }
454 const FIELDS: &[&str] = &["restitution", "friction", "userData"];
455 _serde::Deserializer::deserialize_struct(
456 deserializer,
457 "hkpStorageExtendedMeshShapeMaterial",
458 FIELDS,
459 __hkpStorageExtendedMeshShapeMaterialVisitor {
460 marker: _serde::__private::PhantomData::<
461 hkpStorageExtendedMeshShapeMaterial,
462 >,
463 lifetime: _serde::__private::PhantomData,
464 },
465 )
466 }
467 }
468};