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