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