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