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