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