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 hkSimpleLocalFrame<'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: hkLocalFrame,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "transform"))]
35 #[cfg_attr(feature = "serde", serde(rename = "transform"))]
36 pub m_transform: Transform,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "children"))]
42 #[cfg_attr(feature = "serde", serde(rename = "children"))]
43 pub m_children: Vec<Pointer>,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "parentFrame"))]
50 #[cfg_attr(feature = "serde", serde(rename = "parentFrame"))]
51 pub m_parentFrame: Pointer,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "group"))]
57 #[cfg_attr(feature = "serde", serde(rename = "group"))]
58 pub m_group: Pointer,
59 #[cfg_attr(feature = "serde", serde(borrow))]
64 #[cfg_attr(feature = "json_schema", schemars(rename = "name"))]
65 #[cfg_attr(feature = "serde", serde(rename = "name"))]
66 pub m_name: StringPtr<'a>,
67}
68const _: () = {
69 use havok_serde as _serde;
70 impl<'a> _serde::HavokClass for hkSimpleLocalFrame<'a> {
71 #[inline]
72 fn name(&self) -> &'static str {
73 "hkSimpleLocalFrame"
74 }
75 #[inline]
76 fn signature(&self) -> _serde::__private::Signature {
77 _serde::__private::Signature::new(0xe758f63c)
78 }
79 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
80 fn deps_indexes(&self) -> Vec<usize> {
81 let mut v = Vec::new();
82 v.extend(self.m_children.iter().map(|ptr| ptr.get()));
83 v.push(self.m_parentFrame.get());
84 v.push(self.m_group.get());
85 v
86 }
87 }
88 impl<'a> _serde::Serialize for hkSimpleLocalFrame<'a> {
89 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
90 where
91 S: _serde::ser::Serializer,
92 {
93 let class_meta = self
94 .__ptr
95 .map(|name| (name, _serde::__private::Signature::new(0xe758f63c)));
96 let mut serializer = __serializer
97 .serialize_struct("hkSimpleLocalFrame", class_meta, (112u64, 128u64))?;
98 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
99 serializer
100 .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
101 serializer
102 .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
103 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
104 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
105 serializer.serialize_field("transform", &self.m_transform)?;
106 serializer
107 .serialize_array_field("children", &self.m_children, TypeSize::NonPtr)?;
108 serializer.serialize_field("parentFrame", &self.m_parentFrame)?;
109 serializer.serialize_field("group", &self.m_group)?;
110 serializer.serialize_field("name", &self.m_name)?;
111 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 8usize].as_slice())?;
112 serializer.end()
113 }
114 }
115};
116#[doc(hidden)]
117#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
118const _: () = {
119 use havok_serde as _serde;
120 #[automatically_derived]
121 impl<'de> _serde::Deserialize<'de> for hkSimpleLocalFrame<'de> {
122 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
123 where
124 __D: _serde::Deserializer<'de>,
125 {
126 #[allow(non_camel_case_types)]
127 enum __Field {
128 m_transform,
129 m_children,
130 m_parentFrame,
131 m_group,
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 "transform" => Ok(__Field::m_transform),
157 "children" => Ok(__Field::m_children),
158 "parentFrame" => Ok(__Field::m_parentFrame),
159 "group" => Ok(__Field::m_group),
160 "name" => Ok(__Field::m_name),
161 _ => Ok(__Field::__ignore),
162 }
163 }
164 }
165 impl<'de> _serde::Deserialize<'de> for __Field {
166 #[inline]
167 fn deserialize<__D>(
168 __deserializer: __D,
169 ) -> core::result::Result<Self, __D::Error>
170 where
171 __D: _serde::Deserializer<'de>,
172 {
173 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
174 }
175 }
176 struct __hkSimpleLocalFrameVisitor<'de> {
177 marker: _serde::__private::PhantomData<hkSimpleLocalFrame<'de>>,
178 lifetime: _serde::__private::PhantomData<&'de ()>,
179 }
180 #[allow(clippy::match_single_binding)]
181 #[allow(clippy::reversed_empty_ranges)]
182 #[allow(clippy::single_match)]
183 impl<'de> _serde::de::Visitor<'de> for __hkSimpleLocalFrameVisitor<'de> {
184 type Value = hkSimpleLocalFrame<'de>;
185 fn expecting(
186 &self,
187 __formatter: &mut core::fmt::Formatter,
188 ) -> core::fmt::Result {
189 core::fmt::Formatter::write_str(
190 __formatter,
191 "struct hkSimpleLocalFrame",
192 )
193 }
194 fn visit_struct_for_bytes<__A>(
195 self,
196 mut __map: __A,
197 ) -> _serde::__private::Result<Self::Value, __A::Error>
198 where
199 __A: _serde::de::MapAccess<'de>,
200 {
201 let __ptr = __A::class_ptr(&mut __map);
202 let parent = __A::parent_value(&mut __map)?;
203 let mut m_transform: _serde::__private::Option<Transform> = _serde::__private::None;
204 let mut m_children: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
205 let mut m_parentFrame: _serde::__private::Option<Pointer> = _serde::__private::None;
206 let mut m_group: _serde::__private::Option<Pointer> = _serde::__private::None;
207 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
208 for i in 0..5usize {
209 match i {
210 0usize => {
211 if _serde::__private::Option::is_some(&m_transform) {
212 return _serde::__private::Err(
213 <__A::Error as _serde::de::Error>::duplicate_field(
214 "transform",
215 ),
216 );
217 }
218 __A::pad(&mut __map, 8usize, 0usize)?;
219 m_transform = _serde::__private::Some(
220 match __A::next_value::<Transform>(&mut __map) {
221 _serde::__private::Ok(__val) => __val,
222 _serde::__private::Err(__err) => {
223 return _serde::__private::Err(__err);
224 }
225 },
226 );
227 }
228 1usize => {
229 if _serde::__private::Option::is_some(&m_children) {
230 return _serde::__private::Err(
231 <__A::Error as _serde::de::Error>::duplicate_field(
232 "children",
233 ),
234 );
235 }
236 m_children = _serde::__private::Some(
237 match __A::next_value::<Vec<Pointer>>(&mut __map) {
238 _serde::__private::Ok(__val) => __val,
239 _serde::__private::Err(__err) => {
240 return _serde::__private::Err(__err);
241 }
242 },
243 );
244 }
245 2usize => {
246 if _serde::__private::Option::is_some(&m_parentFrame) {
247 return _serde::__private::Err(
248 <__A::Error as _serde::de::Error>::duplicate_field(
249 "parentFrame",
250 ),
251 );
252 }
253 m_parentFrame = _serde::__private::Some(
254 match __A::next_value::<Pointer>(&mut __map) {
255 _serde::__private::Ok(__val) => __val,
256 _serde::__private::Err(__err) => {
257 return _serde::__private::Err(__err);
258 }
259 },
260 );
261 }
262 3usize => {
263 if _serde::__private::Option::is_some(&m_group) {
264 return _serde::__private::Err(
265 <__A::Error as _serde::de::Error>::duplicate_field("group"),
266 );
267 }
268 m_group = _serde::__private::Some(
269 match __A::next_value::<Pointer>(&mut __map) {
270 _serde::__private::Ok(__val) => __val,
271 _serde::__private::Err(__err) => {
272 return _serde::__private::Err(__err);
273 }
274 },
275 );
276 }
277 4usize => {
278 if _serde::__private::Option::is_some(&m_name) {
279 return _serde::__private::Err(
280 <__A::Error as _serde::de::Error>::duplicate_field("name"),
281 );
282 }
283 m_name = _serde::__private::Some(
284 match __A::next_value::<StringPtr<'de>>(&mut __map) {
285 _serde::__private::Ok(__val) => __val,
286 _serde::__private::Err(__err) => {
287 return _serde::__private::Err(__err);
288 }
289 },
290 );
291 }
292 _ => {}
293 }
294 }
295 __A::pad(&mut __map, 8usize, 8usize)?;
296 let m_transform = match m_transform {
297 _serde::__private::Some(__field) => __field,
298 _serde::__private::None => {
299 return _serde::__private::Err(
300 <__A::Error as _serde::de::Error>::missing_field(
301 "transform",
302 ),
303 );
304 }
305 };
306 let m_children = match m_children {
307 _serde::__private::Some(__field) => __field,
308 _serde::__private::None => {
309 return _serde::__private::Err(
310 <__A::Error as _serde::de::Error>::missing_field("children"),
311 );
312 }
313 };
314 let m_parentFrame = match m_parentFrame {
315 _serde::__private::Some(__field) => __field,
316 _serde::__private::None => {
317 return _serde::__private::Err(
318 <__A::Error as _serde::de::Error>::missing_field(
319 "parentFrame",
320 ),
321 );
322 }
323 };
324 let m_group = match m_group {
325 _serde::__private::Some(__field) => __field,
326 _serde::__private::None => {
327 return _serde::__private::Err(
328 <__A::Error as _serde::de::Error>::missing_field("group"),
329 );
330 }
331 };
332 let m_name = match m_name {
333 _serde::__private::Some(__field) => __field,
334 _serde::__private::None => {
335 return _serde::__private::Err(
336 <__A::Error as _serde::de::Error>::missing_field("name"),
337 );
338 }
339 };
340 _serde::__private::Ok(hkSimpleLocalFrame {
341 __ptr,
342 parent,
343 m_transform,
344 m_children,
345 m_parentFrame,
346 m_group,
347 m_name,
348 })
349 }
350 #[allow(clippy::manual_unwrap_or_default)]
351 fn visit_struct<__A>(
352 self,
353 mut __map: __A,
354 ) -> _serde::__private::Result<Self::Value, __A::Error>
355 where
356 __A: _serde::de::MapAccess<'de>,
357 {
358 let mut m_transform: _serde::__private::Option<Transform> = _serde::__private::None;
359 let mut m_children: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
360 let mut m_parentFrame: _serde::__private::Option<Pointer> = _serde::__private::None;
361 let mut m_group: _serde::__private::Option<Pointer> = _serde::__private::None;
362 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
363 while let _serde::__private::Some(__key) = {
364 __A::next_key::<__Field>(&mut __map)?
365 } {
366 match __key {
367 __Field::m_transform => {
368 #[cfg(
369 any(feature = "strict", feature = "ignore_duplicates")
370 )]
371 if _serde::__private::Option::is_some(&m_transform) {
372 #[cfg(feature = "ignore_duplicates")]
373 {
374 __A::skip_value(&mut __map)?;
375 continue;
376 }
377 #[cfg(feature = "strict")]
378 return _serde::__private::Err(
379 <__A::Error as _serde::de::Error>::duplicate_field(
380 "transform",
381 ),
382 );
383 }
384 m_transform = _serde::__private::Some(
385 match __A::next_value::<Transform>(&mut __map) {
386 _serde::__private::Ok(__val) => __val,
387 _serde::__private::Err(__err) => {
388 return _serde::__private::Err(__err);
389 }
390 },
391 );
392 }
393 __Field::m_children => {
394 #[cfg(
395 any(feature = "strict", feature = "ignore_duplicates")
396 )]
397 if _serde::__private::Option::is_some(&m_children) {
398 #[cfg(feature = "ignore_duplicates")]
399 {
400 __A::skip_value(&mut __map)?;
401 continue;
402 }
403 #[cfg(feature = "strict")]
404 return _serde::__private::Err(
405 <__A::Error as _serde::de::Error>::duplicate_field(
406 "children",
407 ),
408 );
409 }
410 m_children = _serde::__private::Some(
411 match __A::next_value::<Vec<Pointer>>(&mut __map) {
412 _serde::__private::Ok(__val) => __val,
413 _serde::__private::Err(__err) => {
414 return _serde::__private::Err(__err);
415 }
416 },
417 );
418 }
419 __Field::m_parentFrame => {
420 #[cfg(
421 any(feature = "strict", feature = "ignore_duplicates")
422 )]
423 if _serde::__private::Option::is_some(&m_parentFrame) {
424 #[cfg(feature = "ignore_duplicates")]
425 {
426 __A::skip_value(&mut __map)?;
427 continue;
428 }
429 #[cfg(feature = "strict")]
430 return _serde::__private::Err(
431 <__A::Error as _serde::de::Error>::duplicate_field(
432 "parentFrame",
433 ),
434 );
435 }
436 m_parentFrame = _serde::__private::Some(
437 match __A::next_value::<Pointer>(&mut __map) {
438 _serde::__private::Ok(__val) => __val,
439 _serde::__private::Err(__err) => {
440 return _serde::__private::Err(__err);
441 }
442 },
443 );
444 }
445 __Field::m_group => {
446 #[cfg(
447 any(feature = "strict", feature = "ignore_duplicates")
448 )]
449 if _serde::__private::Option::is_some(&m_group) {
450 #[cfg(feature = "ignore_duplicates")]
451 {
452 __A::skip_value(&mut __map)?;
453 continue;
454 }
455 #[cfg(feature = "strict")]
456 return _serde::__private::Err(
457 <__A::Error as _serde::de::Error>::duplicate_field("group"),
458 );
459 }
460 m_group = _serde::__private::Some(
461 match __A::next_value::<Pointer>(&mut __map) {
462 _serde::__private::Ok(__val) => __val,
463 _serde::__private::Err(__err) => {
464 return _serde::__private::Err(__err);
465 }
466 },
467 );
468 }
469 __Field::m_name => {
470 #[cfg(
471 any(feature = "strict", feature = "ignore_duplicates")
472 )]
473 if _serde::__private::Option::is_some(&m_name) {
474 #[cfg(feature = "ignore_duplicates")]
475 {
476 __A::skip_value(&mut __map)?;
477 continue;
478 }
479 #[cfg(feature = "strict")]
480 return _serde::__private::Err(
481 <__A::Error as _serde::de::Error>::duplicate_field("name"),
482 );
483 }
484 m_name = _serde::__private::Some(
485 match __A::next_value::<StringPtr<'de>>(&mut __map) {
486 _serde::__private::Ok(__val) => __val,
487 _serde::__private::Err(__err) => {
488 return _serde::__private::Err(__err);
489 }
490 },
491 );
492 }
493 _ => __A::skip_value(&mut __map)?,
494 }
495 }
496 let m_transform = match m_transform {
497 _serde::__private::Some(__field) => __field,
498 _serde::__private::None => {
499 #[cfg(feature = "strict")]
500 return _serde::__private::Err(
501 <__A::Error as _serde::de::Error>::missing_field(
502 "transform",
503 ),
504 );
505 #[cfg(not(feature = "strict"))] Default::default()
506 }
507 };
508 let m_children = match m_children {
509 _serde::__private::Some(__field) => __field,
510 _serde::__private::None => {
511 #[cfg(feature = "strict")]
512 return _serde::__private::Err(
513 <__A::Error as _serde::de::Error>::missing_field("children"),
514 );
515 #[cfg(not(feature = "strict"))] Default::default()
516 }
517 };
518 let m_parentFrame = match m_parentFrame {
519 _serde::__private::Some(__field) => __field,
520 _serde::__private::None => {
521 #[cfg(feature = "strict")]
522 return _serde::__private::Err(
523 <__A::Error as _serde::de::Error>::missing_field(
524 "parentFrame",
525 ),
526 );
527 #[cfg(not(feature = "strict"))] Default::default()
528 }
529 };
530 let m_group = match m_group {
531 _serde::__private::Some(__field) => __field,
532 _serde::__private::None => {
533 #[cfg(feature = "strict")]
534 return _serde::__private::Err(
535 <__A::Error as _serde::de::Error>::missing_field("group"),
536 );
537 #[cfg(not(feature = "strict"))] Default::default()
538 }
539 };
540 let m_name = match m_name {
541 _serde::__private::Some(__field) => __field,
542 _serde::__private::None => {
543 #[cfg(feature = "strict")]
544 return _serde::__private::Err(
545 <__A::Error as _serde::de::Error>::missing_field("name"),
546 );
547 #[cfg(not(feature = "strict"))] Default::default()
548 }
549 };
550 let __ptr = None;
551 let parent = hkBaseObject { __ptr };
552 let parent = hkReferencedObject {
553 __ptr,
554 parent,
555 ..Default::default()
556 };
557 let parent = hkLocalFrame { __ptr, parent };
558 let __ptr = __A::class_ptr(&mut __map);
559 _serde::__private::Ok(hkSimpleLocalFrame {
560 __ptr,
561 parent,
562 m_transform,
563 m_children,
564 m_parentFrame,
565 m_group,
566 m_name,
567 })
568 }
569 }
570 const FIELDS: &[&str] = &[
571 "transform",
572 "children",
573 "parentFrame",
574 "group",
575 "name",
576 ];
577 _serde::Deserializer::deserialize_struct(
578 deserializer,
579 "hkSimpleLocalFrame",
580 FIELDS,
581 __hkSimpleLocalFrameVisitor {
582 marker: _serde::__private::PhantomData::<hkSimpleLocalFrame>,
583 lifetime: _serde::__private::PhantomData,
584 },
585 )
586 }
587 }
588};