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 hkbGetWorldFromModelModifier<'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 #[cfg_attr(feature = "serde", serde(borrow))]
30 pub parent: hkbModifier<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "translationOut"))]
36 #[cfg_attr(feature = "serde", serde(rename = "translationOut"))]
37 pub m_translationOut: Vector4,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "rotationOut"))]
43 #[cfg_attr(feature = "serde", serde(rename = "rotationOut"))]
44 pub m_rotationOut: Quaternion,
45}
46const _: () = {
47 use havok_serde as _serde;
48 impl<'a> _serde::HavokClass for hkbGetWorldFromModelModifier<'a> {
49 #[inline]
50 fn name(&self) -> &'static str {
51 "hkbGetWorldFromModelModifier"
52 }
53 #[inline]
54 fn signature(&self) -> _serde::__private::Signature {
55 _serde::__private::Signature::new(0x873fc6f7)
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.push(self.parent.parent.parent.m_variableBindingSet.get());
61 v
62 }
63 }
64 impl<'a> _serde::Serialize for hkbGetWorldFromModelModifier<'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(0x873fc6f7)));
72 let mut serializer = __serializer
73 .serialize_struct(
74 "hkbGetWorldFromModelModifier",
75 class_meta,
76 (80u64, 112u64),
77 )?;
78 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
79 serializer
80 .skip_field(
81 "memSizeAndFlags",
82 &self.parent.parent.parent.parent.m_memSizeAndFlags,
83 )?;
84 serializer
85 .skip_field(
86 "referenceCount",
87 &self.parent.parent.parent.parent.m_referenceCount,
88 )?;
89 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
90 serializer
91 .serialize_field(
92 "variableBindingSet",
93 &self.parent.parent.parent.m_variableBindingSet,
94 )?;
95 serializer
96 .skip_array_field(
97 "cachedBindables",
98 &self.parent.parent.parent.m_cachedBindables,
99 TypeSize::NonPtr,
100 )?;
101 serializer
102 .skip_field(
103 "areBindablesCached",
104 &self.parent.parent.parent.m_areBindablesCached,
105 )?;
106 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
107 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
108 serializer.serialize_field("name", &self.parent.parent.m_name)?;
109 serializer.skip_field("id", &self.parent.parent.m_id)?;
110 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
111 serializer
112 .skip_fixed_array_field(
113 "padNode",
114 self.parent.parent.m_padNode.as_slice(),
115 TypeSize::NonPtr,
116 )?;
117 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
118 serializer.serialize_field("enable", &self.parent.m_enable)?;
119 serializer
120 .skip_fixed_array_field(
121 "padModifier",
122 self.parent.m_padModifier.as_slice(),
123 TypeSize::NonPtr,
124 )?;
125 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
126 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
127 serializer.serialize_field("translationOut", &self.m_translationOut)?;
128 serializer.serialize_field("rotationOut", &self.m_rotationOut)?;
129 serializer.end()
130 }
131 }
132};
133#[doc(hidden)]
134#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
135const _: () = {
136 use havok_serde as _serde;
137 #[automatically_derived]
138 impl<'de> _serde::Deserialize<'de> for hkbGetWorldFromModelModifier<'de> {
139 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
140 where
141 __D: _serde::Deserializer<'de>,
142 {
143 #[allow(non_camel_case_types)]
144 enum __Field {
145 m_variableBindingSet,
146 m_userData,
147 m_name,
148 m_enable,
149 m_translationOut,
150 m_rotationOut,
151 __ignore,
152 }
153 struct __FieldVisitor;
154 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
155 type Value = __Field;
156 fn expecting(
157 &self,
158 __formatter: &mut core::fmt::Formatter,
159 ) -> core::fmt::Result {
160 core::fmt::Formatter::write_str(__formatter, "field identifier")
161 }
162 #[allow(clippy::match_single_binding)]
164 #[allow(clippy::reversed_empty_ranges)]
165 #[allow(clippy::single_match)]
166 fn visit_key<__E>(
167 self,
168 __value: &str,
169 ) -> core::result::Result<Self::Value, __E>
170 where
171 __E: _serde::de::Error,
172 {
173 match __value {
174 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
175 "userData" => Ok(__Field::m_userData),
176 "name" => Ok(__Field::m_name),
177 "enable" => Ok(__Field::m_enable),
178 "translationOut" => Ok(__Field::m_translationOut),
179 "rotationOut" => Ok(__Field::m_rotationOut),
180 _ => Ok(__Field::__ignore),
181 }
182 }
183 }
184 impl<'de> _serde::Deserialize<'de> for __Field {
185 #[inline]
186 fn deserialize<__D>(
187 __deserializer: __D,
188 ) -> core::result::Result<Self, __D::Error>
189 where
190 __D: _serde::Deserializer<'de>,
191 {
192 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
193 }
194 }
195 struct __hkbGetWorldFromModelModifierVisitor<'de> {
196 marker: _serde::__private::PhantomData<
197 hkbGetWorldFromModelModifier<'de>,
198 >,
199 lifetime: _serde::__private::PhantomData<&'de ()>,
200 }
201 #[allow(clippy::match_single_binding)]
202 #[allow(clippy::reversed_empty_ranges)]
203 #[allow(clippy::single_match)]
204 impl<'de> _serde::de::Visitor<'de>
205 for __hkbGetWorldFromModelModifierVisitor<'de> {
206 type Value = hkbGetWorldFromModelModifier<'de>;
207 fn expecting(
208 &self,
209 __formatter: &mut core::fmt::Formatter,
210 ) -> core::fmt::Result {
211 core::fmt::Formatter::write_str(
212 __formatter,
213 "struct hkbGetWorldFromModelModifier",
214 )
215 }
216 fn visit_struct_for_bytes<__A>(
217 self,
218 mut __map: __A,
219 ) -> _serde::__private::Result<Self::Value, __A::Error>
220 where
221 __A: _serde::de::MapAccess<'de>,
222 {
223 let __ptr = __A::class_ptr(&mut __map);
224 let parent = __A::parent_value(&mut __map)?;
225 let mut m_translationOut: _serde::__private::Option<Vector4> = _serde::__private::None;
226 let mut m_rotationOut: _serde::__private::Option<Quaternion> = _serde::__private::None;
227 for i in 0..2usize {
228 match i {
229 0usize => {
230 if _serde::__private::Option::is_some(&m_translationOut) {
231 return _serde::__private::Err(
232 <__A::Error as _serde::de::Error>::duplicate_field(
233 "translationOut",
234 ),
235 );
236 }
237 __A::pad(&mut __map, 4usize, 0usize)?;
238 m_translationOut = _serde::__private::Some(
239 match __A::next_value::<Vector4>(&mut __map) {
240 _serde::__private::Ok(__val) => __val,
241 _serde::__private::Err(__err) => {
242 return _serde::__private::Err(__err);
243 }
244 },
245 );
246 }
247 1usize => {
248 if _serde::__private::Option::is_some(&m_rotationOut) {
249 return _serde::__private::Err(
250 <__A::Error as _serde::de::Error>::duplicate_field(
251 "rotationOut",
252 ),
253 );
254 }
255 m_rotationOut = _serde::__private::Some(
256 match __A::next_value::<Quaternion>(&mut __map) {
257 _serde::__private::Ok(__val) => __val,
258 _serde::__private::Err(__err) => {
259 return _serde::__private::Err(__err);
260 }
261 },
262 );
263 }
264 _ => {}
265 }
266 }
267 let m_translationOut = match m_translationOut {
268 _serde::__private::Some(__field) => __field,
269 _serde::__private::None => {
270 return _serde::__private::Err(
271 <__A::Error as _serde::de::Error>::missing_field(
272 "translationOut",
273 ),
274 );
275 }
276 };
277 let m_rotationOut = match m_rotationOut {
278 _serde::__private::Some(__field) => __field,
279 _serde::__private::None => {
280 return _serde::__private::Err(
281 <__A::Error as _serde::de::Error>::missing_field(
282 "rotationOut",
283 ),
284 );
285 }
286 };
287 _serde::__private::Ok(hkbGetWorldFromModelModifier {
288 __ptr,
289 parent,
290 m_translationOut,
291 m_rotationOut,
292 })
293 }
294 #[allow(clippy::manual_unwrap_or_default)]
295 fn visit_struct<__A>(
296 self,
297 mut __map: __A,
298 ) -> _serde::__private::Result<Self::Value, __A::Error>
299 where
300 __A: _serde::de::MapAccess<'de>,
301 {
302 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
303 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
304 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
305 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
306 let mut m_translationOut: _serde::__private::Option<Vector4> = _serde::__private::None;
307 let mut m_rotationOut: _serde::__private::Option<Quaternion> = _serde::__private::None;
308 while let _serde::__private::Some(__key) = {
309 __A::next_key::<__Field>(&mut __map)?
310 } {
311 match __key {
312 __Field::m_variableBindingSet => {
313 #[cfg(
314 any(feature = "strict", feature = "ignore_duplicates")
315 )]
316 if _serde::__private::Option::is_some(
317 &m_variableBindingSet,
318 ) {
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 "variableBindingSet",
328 ),
329 );
330 }
331 m_variableBindingSet = _serde::__private::Some(
332 match __A::next_value::<Pointer>(&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_userData => {
341 #[cfg(
342 any(feature = "strict", feature = "ignore_duplicates")
343 )]
344 if _serde::__private::Option::is_some(&m_userData) {
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 "userData",
354 ),
355 );
356 }
357 m_userData = _serde::__private::Some(
358 match __A::next_value::<Ulong>(&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_name => {
367 #[cfg(
368 any(feature = "strict", feature = "ignore_duplicates")
369 )]
370 if _serde::__private::Option::is_some(&m_name) {
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("name"),
379 );
380 }
381 m_name = _serde::__private::Some(
382 match __A::next_value::<StringPtr<'de>>(&mut __map) {
383 _serde::__private::Ok(__val) => __val,
384 _serde::__private::Err(__err) => {
385 return _serde::__private::Err(__err);
386 }
387 },
388 );
389 }
390 __Field::m_enable => {
391 #[cfg(
392 any(feature = "strict", feature = "ignore_duplicates")
393 )]
394 if _serde::__private::Option::is_some(&m_enable) {
395 #[cfg(feature = "ignore_duplicates")]
396 {
397 __A::skip_value(&mut __map)?;
398 continue;
399 }
400 #[cfg(feature = "strict")]
401 return _serde::__private::Err(
402 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
403 );
404 }
405 m_enable = _serde::__private::Some(
406 match __A::next_value::<bool>(&mut __map) {
407 _serde::__private::Ok(__val) => __val,
408 _serde::__private::Err(__err) => {
409 return _serde::__private::Err(__err);
410 }
411 },
412 );
413 }
414 __Field::m_translationOut => {
415 #[cfg(
416 any(feature = "strict", feature = "ignore_duplicates")
417 )]
418 if _serde::__private::Option::is_some(&m_translationOut) {
419 #[cfg(feature = "ignore_duplicates")]
420 {
421 __A::skip_value(&mut __map)?;
422 continue;
423 }
424 #[cfg(feature = "strict")]
425 return _serde::__private::Err(
426 <__A::Error as _serde::de::Error>::duplicate_field(
427 "translationOut",
428 ),
429 );
430 }
431 m_translationOut = _serde::__private::Some(
432 match __A::next_value::<Vector4>(&mut __map) {
433 _serde::__private::Ok(__val) => __val,
434 _serde::__private::Err(__err) => {
435 return _serde::__private::Err(__err);
436 }
437 },
438 );
439 }
440 __Field::m_rotationOut => {
441 #[cfg(
442 any(feature = "strict", feature = "ignore_duplicates")
443 )]
444 if _serde::__private::Option::is_some(&m_rotationOut) {
445 #[cfg(feature = "ignore_duplicates")]
446 {
447 __A::skip_value(&mut __map)?;
448 continue;
449 }
450 #[cfg(feature = "strict")]
451 return _serde::__private::Err(
452 <__A::Error as _serde::de::Error>::duplicate_field(
453 "rotationOut",
454 ),
455 );
456 }
457 m_rotationOut = _serde::__private::Some(
458 match __A::next_value::<Quaternion>(&mut __map) {
459 _serde::__private::Ok(__val) => __val,
460 _serde::__private::Err(__err) => {
461 return _serde::__private::Err(__err);
462 }
463 },
464 );
465 }
466 _ => __A::skip_value(&mut __map)?,
467 }
468 }
469 let m_variableBindingSet = match m_variableBindingSet {
470 _serde::__private::Some(__field) => __field,
471 _serde::__private::None => {
472 #[cfg(feature = "strict")]
473 return _serde::__private::Err(
474 <__A::Error as _serde::de::Error>::missing_field(
475 "variableBindingSet",
476 ),
477 );
478 #[cfg(not(feature = "strict"))] Default::default()
479 }
480 };
481 let m_userData = match m_userData {
482 _serde::__private::Some(__field) => __field,
483 _serde::__private::None => {
484 #[cfg(feature = "strict")]
485 return _serde::__private::Err(
486 <__A::Error as _serde::de::Error>::missing_field("userData"),
487 );
488 #[cfg(not(feature = "strict"))] Default::default()
489 }
490 };
491 let m_name = match m_name {
492 _serde::__private::Some(__field) => __field,
493 _serde::__private::None => {
494 #[cfg(feature = "strict")]
495 return _serde::__private::Err(
496 <__A::Error as _serde::de::Error>::missing_field("name"),
497 );
498 #[cfg(not(feature = "strict"))] Default::default()
499 }
500 };
501 let m_enable = match m_enable {
502 _serde::__private::Some(__field) => __field,
503 _serde::__private::None => {
504 #[cfg(feature = "strict")]
505 return _serde::__private::Err(
506 <__A::Error as _serde::de::Error>::missing_field("enable"),
507 );
508 #[cfg(not(feature = "strict"))] Default::default()
509 }
510 };
511 let m_translationOut = match m_translationOut {
512 _serde::__private::Some(__field) => __field,
513 _serde::__private::None => {
514 #[cfg(feature = "strict")]
515 return _serde::__private::Err(
516 <__A::Error as _serde::de::Error>::missing_field(
517 "translationOut",
518 ),
519 );
520 #[cfg(not(feature = "strict"))] Default::default()
521 }
522 };
523 let m_rotationOut = match m_rotationOut {
524 _serde::__private::Some(__field) => __field,
525 _serde::__private::None => {
526 #[cfg(feature = "strict")]
527 return _serde::__private::Err(
528 <__A::Error as _serde::de::Error>::missing_field(
529 "rotationOut",
530 ),
531 );
532 #[cfg(not(feature = "strict"))] Default::default()
533 }
534 };
535 let __ptr = None;
536 let parent = hkBaseObject { __ptr };
537 let parent = hkReferencedObject {
538 __ptr,
539 parent,
540 ..Default::default()
541 };
542 let parent = hkbBindable {
543 __ptr,
544 parent,
545 m_variableBindingSet,
546 ..Default::default()
547 };
548 let parent = hkbNode {
549 __ptr,
550 parent,
551 m_userData,
552 m_name,
553 ..Default::default()
554 };
555 let parent = hkbModifier {
556 __ptr,
557 parent,
558 m_enable,
559 ..Default::default()
560 };
561 let __ptr = __A::class_ptr(&mut __map);
562 _serde::__private::Ok(hkbGetWorldFromModelModifier {
563 __ptr,
564 parent,
565 m_translationOut,
566 m_rotationOut,
567 })
568 }
569 }
570 const FIELDS: &[&str] = &["translationOut", "rotationOut"];
571 _serde::Deserializer::deserialize_struct(
572 deserializer,
573 "hkbGetWorldFromModelModifier",
574 FIELDS,
575 __hkbGetWorldFromModelModifierVisitor {
576 marker: _serde::__private::PhantomData::<
577 hkbGetWorldFromModelModifier,
578 >,
579 lifetime: _serde::__private::PhantomData,
580 },
581 )
582 }
583 }
584};