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