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 hkbHandIkControlsModifier<'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 = "hands"))]
36 #[cfg_attr(feature = "serde", serde(rename = "hands"))]
37 pub m_hands: Vec<hkbHandIkControlsModifierHand>,
38}
39const _: () = {
40 use havok_serde as _serde;
41 impl<'a> _serde::HavokClass for hkbHandIkControlsModifier<'a> {
42 #[inline]
43 fn name(&self) -> &'static str {
44 "hkbHandIkControlsModifier"
45 }
46 #[inline]
47 fn signature(&self) -> _serde::__private::Signature {
48 _serde::__private::Signature::new(0x9f0488bb)
49 }
50 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
51 fn deps_indexes(&self) -> Vec<usize> {
52 let mut v = Vec::new();
53 v.push(self.parent.parent.parent.m_variableBindingSet.get());
54 v.extend(
55 self
56 .m_hands
57 .iter()
58 .flat_map(|class| class.deps_indexes())
59 .collect::<Vec<usize>>(),
60 );
61 v
62 }
63 }
64 impl<'a> _serde::Serialize for hkbHandIkControlsModifier<'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(0x9f0488bb)));
72 let mut serializer = __serializer
73 .serialize_struct(
74 "hkbHandIkControlsModifier",
75 class_meta,
76 (56u64, 96u64),
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
127 .serialize_array_field(
128 "hands",
129 &self.m_hands,
130 TypeSize::Struct {
131 size_x86: 96u64,
132 size_x86_64: 112u64,
133 },
134 )?;
135 serializer.end()
136 }
137 }
138};
139#[doc(hidden)]
140#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
141const _: () = {
142 use havok_serde as _serde;
143 #[automatically_derived]
144 impl<'de> _serde::Deserialize<'de> for hkbHandIkControlsModifier<'de> {
145 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
146 where
147 __D: _serde::Deserializer<'de>,
148 {
149 #[allow(non_camel_case_types)]
150 enum __Field {
151 m_variableBindingSet,
152 m_userData,
153 m_name,
154 m_enable,
155 m_hands,
156 __ignore,
157 }
158 struct __FieldVisitor;
159 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
160 type Value = __Field;
161 fn expecting(
162 &self,
163 __formatter: &mut core::fmt::Formatter,
164 ) -> core::fmt::Result {
165 core::fmt::Formatter::write_str(__formatter, "field identifier")
166 }
167 #[allow(clippy::match_single_binding)]
169 #[allow(clippy::reversed_empty_ranges)]
170 #[allow(clippy::single_match)]
171 fn visit_key<__E>(
172 self,
173 __value: &str,
174 ) -> core::result::Result<Self::Value, __E>
175 where
176 __E: _serde::de::Error,
177 {
178 match __value {
179 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
180 "userData" => Ok(__Field::m_userData),
181 "name" => Ok(__Field::m_name),
182 "enable" => Ok(__Field::m_enable),
183 "hands" => Ok(__Field::m_hands),
184 _ => Ok(__Field::__ignore),
185 }
186 }
187 }
188 impl<'de> _serde::Deserialize<'de> for __Field {
189 #[inline]
190 fn deserialize<__D>(
191 __deserializer: __D,
192 ) -> core::result::Result<Self, __D::Error>
193 where
194 __D: _serde::Deserializer<'de>,
195 {
196 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
197 }
198 }
199 struct __hkbHandIkControlsModifierVisitor<'de> {
200 marker: _serde::__private::PhantomData<hkbHandIkControlsModifier<'de>>,
201 lifetime: _serde::__private::PhantomData<&'de ()>,
202 }
203 #[allow(clippy::match_single_binding)]
204 #[allow(clippy::reversed_empty_ranges)]
205 #[allow(clippy::single_match)]
206 impl<'de> _serde::de::Visitor<'de>
207 for __hkbHandIkControlsModifierVisitor<'de> {
208 type Value = hkbHandIkControlsModifier<'de>;
209 fn expecting(
210 &self,
211 __formatter: &mut core::fmt::Formatter,
212 ) -> core::fmt::Result {
213 core::fmt::Formatter::write_str(
214 __formatter,
215 "struct hkbHandIkControlsModifier",
216 )
217 }
218 fn visit_struct_for_bytes<__A>(
219 self,
220 mut __map: __A,
221 ) -> _serde::__private::Result<Self::Value, __A::Error>
222 where
223 __A: _serde::de::MapAccess<'de>,
224 {
225 let __ptr = __A::class_ptr(&mut __map);
226 let parent = __A::parent_value(&mut __map)?;
227 let mut m_hands: _serde::__private::Option<
228 Vec<hkbHandIkControlsModifierHand>,
229 > = _serde::__private::None;
230 for i in 0..1usize {
231 match i {
232 0usize => {
233 if _serde::__private::Option::is_some(&m_hands) {
234 return _serde::__private::Err(
235 <__A::Error as _serde::de::Error>::duplicate_field("hands"),
236 );
237 }
238 m_hands = _serde::__private::Some(
239 match __A::next_value::<
240 Vec<hkbHandIkControlsModifierHand>,
241 >(&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_hands = match m_hands {
253 _serde::__private::Some(__field) => __field,
254 _serde::__private::None => {
255 return _serde::__private::Err(
256 <__A::Error as _serde::de::Error>::missing_field("hands"),
257 );
258 }
259 };
260 _serde::__private::Ok(hkbHandIkControlsModifier {
261 __ptr,
262 parent,
263 m_hands,
264 })
265 }
266 #[allow(clippy::manual_unwrap_or_default)]
267 fn visit_struct<__A>(
268 self,
269 mut __map: __A,
270 ) -> _serde::__private::Result<Self::Value, __A::Error>
271 where
272 __A: _serde::de::MapAccess<'de>,
273 {
274 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
275 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
276 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
277 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
278 let mut m_hands: _serde::__private::Option<
279 Vec<hkbHandIkControlsModifierHand>,
280 > = _serde::__private::None;
281 while let _serde::__private::Some(__key) = {
282 __A::next_key::<__Field>(&mut __map)?
283 } {
284 match __key {
285 __Field::m_variableBindingSet => {
286 #[cfg(
287 any(feature = "strict", feature = "ignore_duplicates")
288 )]
289 if _serde::__private::Option::is_some(
290 &m_variableBindingSet,
291 ) {
292 #[cfg(feature = "ignore_duplicates")]
293 {
294 __A::skip_value(&mut __map)?;
295 continue;
296 }
297 #[cfg(feature = "strict")]
298 return _serde::__private::Err(
299 <__A::Error as _serde::de::Error>::duplicate_field(
300 "variableBindingSet",
301 ),
302 );
303 }
304 m_variableBindingSet = _serde::__private::Some(
305 match __A::next_value::<Pointer>(&mut __map) {
306 _serde::__private::Ok(__val) => __val,
307 _serde::__private::Err(__err) => {
308 return _serde::__private::Err(__err);
309 }
310 },
311 );
312 }
313 __Field::m_userData => {
314 #[cfg(
315 any(feature = "strict", feature = "ignore_duplicates")
316 )]
317 if _serde::__private::Option::is_some(&m_userData) {
318 #[cfg(feature = "ignore_duplicates")]
319 {
320 __A::skip_value(&mut __map)?;
321 continue;
322 }
323 #[cfg(feature = "strict")]
324 return _serde::__private::Err(
325 <__A::Error as _serde::de::Error>::duplicate_field(
326 "userData",
327 ),
328 );
329 }
330 m_userData = _serde::__private::Some(
331 match __A::next_value::<Ulong>(&mut __map) {
332 _serde::__private::Ok(__val) => __val,
333 _serde::__private::Err(__err) => {
334 return _serde::__private::Err(__err);
335 }
336 },
337 );
338 }
339 __Field::m_name => {
340 #[cfg(
341 any(feature = "strict", feature = "ignore_duplicates")
342 )]
343 if _serde::__private::Option::is_some(&m_name) {
344 #[cfg(feature = "ignore_duplicates")]
345 {
346 __A::skip_value(&mut __map)?;
347 continue;
348 }
349 #[cfg(feature = "strict")]
350 return _serde::__private::Err(
351 <__A::Error as _serde::de::Error>::duplicate_field("name"),
352 );
353 }
354 m_name = _serde::__private::Some(
355 match __A::next_value::<StringPtr<'de>>(&mut __map) {
356 _serde::__private::Ok(__val) => __val,
357 _serde::__private::Err(__err) => {
358 return _serde::__private::Err(__err);
359 }
360 },
361 );
362 }
363 __Field::m_enable => {
364 #[cfg(
365 any(feature = "strict", feature = "ignore_duplicates")
366 )]
367 if _serde::__private::Option::is_some(&m_enable) {
368 #[cfg(feature = "ignore_duplicates")]
369 {
370 __A::skip_value(&mut __map)?;
371 continue;
372 }
373 #[cfg(feature = "strict")]
374 return _serde::__private::Err(
375 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
376 );
377 }
378 m_enable = _serde::__private::Some(
379 match __A::next_value::<bool>(&mut __map) {
380 _serde::__private::Ok(__val) => __val,
381 _serde::__private::Err(__err) => {
382 return _serde::__private::Err(__err);
383 }
384 },
385 );
386 }
387 __Field::m_hands => {
388 #[cfg(
389 any(feature = "strict", feature = "ignore_duplicates")
390 )]
391 if _serde::__private::Option::is_some(&m_hands) {
392 #[cfg(feature = "ignore_duplicates")]
393 {
394 __A::skip_value(&mut __map)?;
395 continue;
396 }
397 #[cfg(feature = "strict")]
398 return _serde::__private::Err(
399 <__A::Error as _serde::de::Error>::duplicate_field("hands"),
400 );
401 }
402 m_hands = _serde::__private::Some(
403 match __A::next_value::<
404 Vec<hkbHandIkControlsModifierHand>,
405 >(&mut __map) {
406 _serde::__private::Ok(__val) => __val,
407 _serde::__private::Err(__err) => {
408 return _serde::__private::Err(__err);
409 }
410 },
411 );
412 }
413 _ => __A::skip_value(&mut __map)?,
414 }
415 }
416 let m_variableBindingSet = match m_variableBindingSet {
417 _serde::__private::Some(__field) => __field,
418 _serde::__private::None => {
419 #[cfg(feature = "strict")]
420 return _serde::__private::Err(
421 <__A::Error as _serde::de::Error>::missing_field(
422 "variableBindingSet",
423 ),
424 );
425 #[cfg(not(feature = "strict"))] Default::default()
426 }
427 };
428 let m_userData = match m_userData {
429 _serde::__private::Some(__field) => __field,
430 _serde::__private::None => {
431 #[cfg(feature = "strict")]
432 return _serde::__private::Err(
433 <__A::Error as _serde::de::Error>::missing_field("userData"),
434 );
435 #[cfg(not(feature = "strict"))] Default::default()
436 }
437 };
438 let m_name = match m_name {
439 _serde::__private::Some(__field) => __field,
440 _serde::__private::None => {
441 #[cfg(feature = "strict")]
442 return _serde::__private::Err(
443 <__A::Error as _serde::de::Error>::missing_field("name"),
444 );
445 #[cfg(not(feature = "strict"))] Default::default()
446 }
447 };
448 let m_enable = match m_enable {
449 _serde::__private::Some(__field) => __field,
450 _serde::__private::None => {
451 #[cfg(feature = "strict")]
452 return _serde::__private::Err(
453 <__A::Error as _serde::de::Error>::missing_field("enable"),
454 );
455 #[cfg(not(feature = "strict"))] Default::default()
456 }
457 };
458 let m_hands = match m_hands {
459 _serde::__private::Some(__field) => __field,
460 _serde::__private::None => {
461 #[cfg(feature = "strict")]
462 return _serde::__private::Err(
463 <__A::Error as _serde::de::Error>::missing_field("hands"),
464 );
465 #[cfg(not(feature = "strict"))] Default::default()
466 }
467 };
468 let __ptr = None;
469 let parent = hkBaseObject { __ptr };
470 let parent = hkReferencedObject {
471 __ptr,
472 parent,
473 ..Default::default()
474 };
475 let parent = hkbBindable {
476 __ptr,
477 parent,
478 m_variableBindingSet,
479 ..Default::default()
480 };
481 let parent = hkbNode {
482 __ptr,
483 parent,
484 m_userData,
485 m_name,
486 ..Default::default()
487 };
488 let parent = hkbModifier {
489 __ptr,
490 parent,
491 m_enable,
492 ..Default::default()
493 };
494 let __ptr = __A::class_ptr(&mut __map);
495 _serde::__private::Ok(hkbHandIkControlsModifier {
496 __ptr,
497 parent,
498 m_hands,
499 })
500 }
501 }
502 const FIELDS: &[&str] = &["hands"];
503 _serde::Deserializer::deserialize_struct(
504 deserializer,
505 "hkbHandIkControlsModifier",
506 FIELDS,
507 __hkbHandIkControlsModifierVisitor {
508 marker: _serde::__private::PhantomData::<hkbHandIkControlsModifier>,
509 lifetime: _serde::__private::PhantomData,
510 },
511 )
512 }
513 }
514};