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