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