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 hkbSetBehaviorCommand {
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 = "behavior"))]
42 #[cfg_attr(feature = "serde", serde(rename = "behavior"))]
43 pub m_behavior: Pointer,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "rootGenerator"))]
49 #[cfg_attr(feature = "serde", serde(rename = "rootGenerator"))]
50 pub m_rootGenerator: Pointer,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "referencedBehaviors"))]
56 #[cfg_attr(feature = "serde", serde(rename = "referencedBehaviors"))]
57 pub m_referencedBehaviors: Vec<Pointer>,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "startStateIndex"))]
63 #[cfg_attr(feature = "serde", serde(rename = "startStateIndex"))]
64 pub m_startStateIndex: i32,
65 #[cfg_attr(feature = "json_schema", schemars(rename = "randomizeSimulation"))]
70 #[cfg_attr(feature = "serde", serde(rename = "randomizeSimulation"))]
71 pub m_randomizeSimulation: bool,
72 #[cfg_attr(feature = "json_schema", schemars(rename = "padding"))]
77 #[cfg_attr(feature = "serde", serde(rename = "padding"))]
78 pub m_padding: i32,
79}
80const _: () = {
81 use havok_serde as _serde;
82 impl _serde::HavokClass for hkbSetBehaviorCommand {
83 #[inline]
84 fn name(&self) -> &'static str {
85 "hkbSetBehaviorCommand"
86 }
87 #[inline]
88 fn signature(&self) -> _serde::__private::Signature {
89 _serde::__private::Signature::new(0xe18b74b9)
90 }
91 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
92 fn deps_indexes(&self) -> Vec<usize> {
93 let mut v = Vec::new();
94 v.push(self.m_behavior.get());
95 v.push(self.m_rootGenerator.get());
96 v.extend(self.m_referencedBehaviors.iter().map(|ptr| ptr.get()));
97 v
98 }
99 }
100 impl _serde::Serialize for hkbSetBehaviorCommand {
101 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
102 where
103 S: _serde::ser::Serializer,
104 {
105 let class_meta = self
106 .__ptr
107 .map(|name| (name, _serde::__private::Signature::new(0xe18b74b9)));
108 let mut serializer = __serializer
109 .serialize_struct("hkbSetBehaviorCommand", class_meta, (48u64, 72u64))?;
110 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
111 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
112 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
113 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
114 serializer.serialize_field("characterId", &self.m_characterId)?;
115 serializer.serialize_field("behavior", &self.m_behavior)?;
116 serializer.serialize_field("rootGenerator", &self.m_rootGenerator)?;
117 serializer
118 .serialize_array_field(
119 "referencedBehaviors",
120 &self.m_referencedBehaviors,
121 TypeSize::NonPtr,
122 )?;
123 serializer.serialize_field("startStateIndex", &self.m_startStateIndex)?;
124 serializer
125 .serialize_field("randomizeSimulation", &self.m_randomizeSimulation)?;
126 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
127 serializer.serialize_field("padding", &self.m_padding)?;
128 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
129 serializer.end()
130 }
131 }
132};
133#[doc(hidden)]
134#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
135const _: () = {
136 use havok_serde as _serde;
137 #[automatically_derived]
138 impl<'de> _serde::Deserialize<'de> for hkbSetBehaviorCommand {
139 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
140 where
141 __D: _serde::Deserializer<'de>,
142 {
143 #[allow(non_camel_case_types)]
144 enum __Field {
145 m_characterId,
146 m_behavior,
147 m_rootGenerator,
148 m_referencedBehaviors,
149 m_startStateIndex,
150 m_randomizeSimulation,
151 m_padding,
152 __ignore,
153 }
154 struct __FieldVisitor;
155 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
156 type Value = __Field;
157 fn expecting(
158 &self,
159 __formatter: &mut core::fmt::Formatter,
160 ) -> core::fmt::Result {
161 core::fmt::Formatter::write_str(__formatter, "field identifier")
162 }
163 #[allow(clippy::match_single_binding)]
165 #[allow(clippy::reversed_empty_ranges)]
166 #[allow(clippy::single_match)]
167 fn visit_key<__E>(
168 self,
169 __value: &str,
170 ) -> core::result::Result<Self::Value, __E>
171 where
172 __E: _serde::de::Error,
173 {
174 match __value {
175 "characterId" => Ok(__Field::m_characterId),
176 "behavior" => Ok(__Field::m_behavior),
177 "rootGenerator" => Ok(__Field::m_rootGenerator),
178 "referencedBehaviors" => Ok(__Field::m_referencedBehaviors),
179 "startStateIndex" => Ok(__Field::m_startStateIndex),
180 "randomizeSimulation" => Ok(__Field::m_randomizeSimulation),
181 "padding" => Ok(__Field::m_padding),
182 _ => Ok(__Field::__ignore),
183 }
184 }
185 }
186 impl<'de> _serde::Deserialize<'de> for __Field {
187 #[inline]
188 fn deserialize<__D>(
189 __deserializer: __D,
190 ) -> core::result::Result<Self, __D::Error>
191 where
192 __D: _serde::Deserializer<'de>,
193 {
194 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
195 }
196 }
197 struct __hkbSetBehaviorCommandVisitor<'de> {
198 marker: _serde::__private::PhantomData<hkbSetBehaviorCommand>,
199 lifetime: _serde::__private::PhantomData<&'de ()>,
200 }
201 #[allow(clippy::match_single_binding)]
202 #[allow(clippy::reversed_empty_ranges)]
203 #[allow(clippy::single_match)]
204 impl<'de> _serde::de::Visitor<'de> for __hkbSetBehaviorCommandVisitor<'de> {
205 type Value = hkbSetBehaviorCommand;
206 fn expecting(
207 &self,
208 __formatter: &mut core::fmt::Formatter,
209 ) -> core::fmt::Result {
210 core::fmt::Formatter::write_str(
211 __formatter,
212 "struct hkbSetBehaviorCommand",
213 )
214 }
215 fn visit_struct_for_bytes<__A>(
216 self,
217 mut __map: __A,
218 ) -> _serde::__private::Result<Self::Value, __A::Error>
219 where
220 __A: _serde::de::MapAccess<'de>,
221 {
222 let __ptr = __A::class_ptr(&mut __map);
223 let parent = __A::parent_value(&mut __map)?;
224 let mut m_characterId: _serde::__private::Option<u64> = _serde::__private::None;
225 let mut m_behavior: _serde::__private::Option<Pointer> = _serde::__private::None;
226 let mut m_rootGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
227 let mut m_referencedBehaviors: _serde::__private::Option<
228 Vec<Pointer>,
229 > = _serde::__private::None;
230 let mut m_startStateIndex: _serde::__private::Option<i32> = _serde::__private::None;
231 let mut m_randomizeSimulation: _serde::__private::Option<bool> = _serde::__private::None;
232 let mut m_padding: _serde::__private::Option<i32> = _serde::__private::None;
233 for i in 0..7usize {
234 match i {
235 0usize => {
236 if _serde::__private::Option::is_some(&m_characterId) {
237 return _serde::__private::Err(
238 <__A::Error as _serde::de::Error>::duplicate_field(
239 "characterId",
240 ),
241 );
242 }
243 m_characterId = _serde::__private::Some(
244 match __A::next_value::<u64>(&mut __map) {
245 _serde::__private::Ok(__val) => __val,
246 _serde::__private::Err(__err) => {
247 return _serde::__private::Err(__err);
248 }
249 },
250 );
251 }
252 1usize => {
253 if _serde::__private::Option::is_some(&m_behavior) {
254 return _serde::__private::Err(
255 <__A::Error as _serde::de::Error>::duplicate_field(
256 "behavior",
257 ),
258 );
259 }
260 m_behavior = _serde::__private::Some(
261 match __A::next_value::<Pointer>(&mut __map) {
262 _serde::__private::Ok(__val) => __val,
263 _serde::__private::Err(__err) => {
264 return _serde::__private::Err(__err);
265 }
266 },
267 );
268 }
269 2usize => {
270 if _serde::__private::Option::is_some(&m_rootGenerator) {
271 return _serde::__private::Err(
272 <__A::Error as _serde::de::Error>::duplicate_field(
273 "rootGenerator",
274 ),
275 );
276 }
277 m_rootGenerator = _serde::__private::Some(
278 match __A::next_value::<Pointer>(&mut __map) {
279 _serde::__private::Ok(__val) => __val,
280 _serde::__private::Err(__err) => {
281 return _serde::__private::Err(__err);
282 }
283 },
284 );
285 }
286 3usize => {
287 if _serde::__private::Option::is_some(
288 &m_referencedBehaviors,
289 ) {
290 return _serde::__private::Err(
291 <__A::Error as _serde::de::Error>::duplicate_field(
292 "referencedBehaviors",
293 ),
294 );
295 }
296 m_referencedBehaviors = _serde::__private::Some(
297 match __A::next_value::<Vec<Pointer>>(&mut __map) {
298 _serde::__private::Ok(__val) => __val,
299 _serde::__private::Err(__err) => {
300 return _serde::__private::Err(__err);
301 }
302 },
303 );
304 }
305 4usize => {
306 if _serde::__private::Option::is_some(&m_startStateIndex) {
307 return _serde::__private::Err(
308 <__A::Error as _serde::de::Error>::duplicate_field(
309 "startStateIndex",
310 ),
311 );
312 }
313 m_startStateIndex = _serde::__private::Some(
314 match __A::next_value::<i32>(&mut __map) {
315 _serde::__private::Ok(__val) => __val,
316 _serde::__private::Err(__err) => {
317 return _serde::__private::Err(__err);
318 }
319 },
320 );
321 }
322 5usize => {
323 if _serde::__private::Option::is_some(
324 &m_randomizeSimulation,
325 ) {
326 return _serde::__private::Err(
327 <__A::Error as _serde::de::Error>::duplicate_field(
328 "randomizeSimulation",
329 ),
330 );
331 }
332 m_randomizeSimulation = _serde::__private::Some(
333 match __A::next_value::<bool>(&mut __map) {
334 _serde::__private::Ok(__val) => __val,
335 _serde::__private::Err(__err) => {
336 return _serde::__private::Err(__err);
337 }
338 },
339 );
340 }
341 6usize => {
342 if _serde::__private::Option::is_some(&m_padding) {
343 return _serde::__private::Err(
344 <__A::Error as _serde::de::Error>::duplicate_field(
345 "padding",
346 ),
347 );
348 }
349 __A::pad(&mut __map, 3usize, 3usize)?;
350 m_padding = _serde::__private::Some(
351 match __A::next_value::<i32>(&mut __map) {
352 _serde::__private::Ok(__val) => __val,
353 _serde::__private::Err(__err) => {
354 return _serde::__private::Err(__err);
355 }
356 },
357 );
358 }
359 _ => {}
360 }
361 }
362 __A::pad(&mut __map, 0usize, 4usize)?;
363 let m_characterId = match m_characterId {
364 _serde::__private::Some(__field) => __field,
365 _serde::__private::None => {
366 return _serde::__private::Err(
367 <__A::Error as _serde::de::Error>::missing_field(
368 "characterId",
369 ),
370 );
371 }
372 };
373 let m_behavior = match m_behavior {
374 _serde::__private::Some(__field) => __field,
375 _serde::__private::None => {
376 return _serde::__private::Err(
377 <__A::Error as _serde::de::Error>::missing_field("behavior"),
378 );
379 }
380 };
381 let m_rootGenerator = match m_rootGenerator {
382 _serde::__private::Some(__field) => __field,
383 _serde::__private::None => {
384 return _serde::__private::Err(
385 <__A::Error as _serde::de::Error>::missing_field(
386 "rootGenerator",
387 ),
388 );
389 }
390 };
391 let m_referencedBehaviors = match m_referencedBehaviors {
392 _serde::__private::Some(__field) => __field,
393 _serde::__private::None => {
394 return _serde::__private::Err(
395 <__A::Error as _serde::de::Error>::missing_field(
396 "referencedBehaviors",
397 ),
398 );
399 }
400 };
401 let m_startStateIndex = match m_startStateIndex {
402 _serde::__private::Some(__field) => __field,
403 _serde::__private::None => {
404 return _serde::__private::Err(
405 <__A::Error as _serde::de::Error>::missing_field(
406 "startStateIndex",
407 ),
408 );
409 }
410 };
411 let m_randomizeSimulation = match m_randomizeSimulation {
412 _serde::__private::Some(__field) => __field,
413 _serde::__private::None => {
414 return _serde::__private::Err(
415 <__A::Error as _serde::de::Error>::missing_field(
416 "randomizeSimulation",
417 ),
418 );
419 }
420 };
421 let m_padding = match m_padding {
422 _serde::__private::Some(__field) => __field,
423 _serde::__private::None => {
424 return _serde::__private::Err(
425 <__A::Error as _serde::de::Error>::missing_field("padding"),
426 );
427 }
428 };
429 _serde::__private::Ok(hkbSetBehaviorCommand {
430 __ptr,
431 parent,
432 m_characterId,
433 m_behavior,
434 m_rootGenerator,
435 m_referencedBehaviors,
436 m_startStateIndex,
437 m_randomizeSimulation,
438 m_padding,
439 })
440 }
441 #[allow(clippy::manual_unwrap_or_default)]
442 fn visit_struct<__A>(
443 self,
444 mut __map: __A,
445 ) -> _serde::__private::Result<Self::Value, __A::Error>
446 where
447 __A: _serde::de::MapAccess<'de>,
448 {
449 let mut m_characterId: _serde::__private::Option<u64> = _serde::__private::None;
450 let mut m_behavior: _serde::__private::Option<Pointer> = _serde::__private::None;
451 let mut m_rootGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
452 let mut m_referencedBehaviors: _serde::__private::Option<
453 Vec<Pointer>,
454 > = _serde::__private::None;
455 let mut m_startStateIndex: _serde::__private::Option<i32> = _serde::__private::None;
456 let mut m_randomizeSimulation: _serde::__private::Option<bool> = _serde::__private::None;
457 let mut m_padding: _serde::__private::Option<i32> = _serde::__private::None;
458 while let _serde::__private::Some(__key) = {
459 __A::next_key::<__Field>(&mut __map)?
460 } {
461 match __key {
462 __Field::m_characterId => {
463 #[cfg(
464 any(feature = "strict", feature = "ignore_duplicates")
465 )]
466 if _serde::__private::Option::is_some(&m_characterId) {
467 #[cfg(feature = "ignore_duplicates")]
468 {
469 __A::skip_value(&mut __map)?;
470 continue;
471 }
472 #[cfg(feature = "strict")]
473 return _serde::__private::Err(
474 <__A::Error as _serde::de::Error>::duplicate_field(
475 "characterId",
476 ),
477 );
478 }
479 m_characterId = _serde::__private::Some(
480 match __A::next_value::<u64>(&mut __map) {
481 _serde::__private::Ok(__val) => __val,
482 _serde::__private::Err(__err) => {
483 return _serde::__private::Err(__err);
484 }
485 },
486 );
487 }
488 __Field::m_behavior => {
489 #[cfg(
490 any(feature = "strict", feature = "ignore_duplicates")
491 )]
492 if _serde::__private::Option::is_some(&m_behavior) {
493 #[cfg(feature = "ignore_duplicates")]
494 {
495 __A::skip_value(&mut __map)?;
496 continue;
497 }
498 #[cfg(feature = "strict")]
499 return _serde::__private::Err(
500 <__A::Error as _serde::de::Error>::duplicate_field(
501 "behavior",
502 ),
503 );
504 }
505 m_behavior = _serde::__private::Some(
506 match __A::next_value::<Pointer>(&mut __map) {
507 _serde::__private::Ok(__val) => __val,
508 _serde::__private::Err(__err) => {
509 return _serde::__private::Err(__err);
510 }
511 },
512 );
513 }
514 __Field::m_rootGenerator => {
515 #[cfg(
516 any(feature = "strict", feature = "ignore_duplicates")
517 )]
518 if _serde::__private::Option::is_some(&m_rootGenerator) {
519 #[cfg(feature = "ignore_duplicates")]
520 {
521 __A::skip_value(&mut __map)?;
522 continue;
523 }
524 #[cfg(feature = "strict")]
525 return _serde::__private::Err(
526 <__A::Error as _serde::de::Error>::duplicate_field(
527 "rootGenerator",
528 ),
529 );
530 }
531 m_rootGenerator = _serde::__private::Some(
532 match __A::next_value::<Pointer>(&mut __map) {
533 _serde::__private::Ok(__val) => __val,
534 _serde::__private::Err(__err) => {
535 return _serde::__private::Err(__err);
536 }
537 },
538 );
539 }
540 __Field::m_referencedBehaviors => {
541 #[cfg(
542 any(feature = "strict", feature = "ignore_duplicates")
543 )]
544 if _serde::__private::Option::is_some(
545 &m_referencedBehaviors,
546 ) {
547 #[cfg(feature = "ignore_duplicates")]
548 {
549 __A::skip_value(&mut __map)?;
550 continue;
551 }
552 #[cfg(feature = "strict")]
553 return _serde::__private::Err(
554 <__A::Error as _serde::de::Error>::duplicate_field(
555 "referencedBehaviors",
556 ),
557 );
558 }
559 m_referencedBehaviors = _serde::__private::Some(
560 match __A::next_value::<Vec<Pointer>>(&mut __map) {
561 _serde::__private::Ok(__val) => __val,
562 _serde::__private::Err(__err) => {
563 return _serde::__private::Err(__err);
564 }
565 },
566 );
567 }
568 __Field::m_startStateIndex => {
569 #[cfg(
570 any(feature = "strict", feature = "ignore_duplicates")
571 )]
572 if _serde::__private::Option::is_some(&m_startStateIndex) {
573 #[cfg(feature = "ignore_duplicates")]
574 {
575 __A::skip_value(&mut __map)?;
576 continue;
577 }
578 #[cfg(feature = "strict")]
579 return _serde::__private::Err(
580 <__A::Error as _serde::de::Error>::duplicate_field(
581 "startStateIndex",
582 ),
583 );
584 }
585 m_startStateIndex = _serde::__private::Some(
586 match __A::next_value::<i32>(&mut __map) {
587 _serde::__private::Ok(__val) => __val,
588 _serde::__private::Err(__err) => {
589 return _serde::__private::Err(__err);
590 }
591 },
592 );
593 }
594 __Field::m_randomizeSimulation => {
595 #[cfg(
596 any(feature = "strict", feature = "ignore_duplicates")
597 )]
598 if _serde::__private::Option::is_some(
599 &m_randomizeSimulation,
600 ) {
601 #[cfg(feature = "ignore_duplicates")]
602 {
603 __A::skip_value(&mut __map)?;
604 continue;
605 }
606 #[cfg(feature = "strict")]
607 return _serde::__private::Err(
608 <__A::Error as _serde::de::Error>::duplicate_field(
609 "randomizeSimulation",
610 ),
611 );
612 }
613 m_randomizeSimulation = _serde::__private::Some(
614 match __A::next_value::<bool>(&mut __map) {
615 _serde::__private::Ok(__val) => __val,
616 _serde::__private::Err(__err) => {
617 return _serde::__private::Err(__err);
618 }
619 },
620 );
621 }
622 __Field::m_padding => {
623 #[cfg(
624 any(feature = "strict", feature = "ignore_duplicates")
625 )]
626 if _serde::__private::Option::is_some(&m_padding) {
627 #[cfg(feature = "ignore_duplicates")]
628 {
629 __A::skip_value(&mut __map)?;
630 continue;
631 }
632 #[cfg(feature = "strict")]
633 return _serde::__private::Err(
634 <__A::Error as _serde::de::Error>::duplicate_field(
635 "padding",
636 ),
637 );
638 }
639 m_padding = _serde::__private::Some(
640 match __A::next_value::<i32>(&mut __map) {
641 _serde::__private::Ok(__val) => __val,
642 _serde::__private::Err(__err) => {
643 return _serde::__private::Err(__err);
644 }
645 },
646 );
647 }
648 _ => __A::skip_value(&mut __map)?,
649 }
650 }
651 let m_characterId = match m_characterId {
652 _serde::__private::Some(__field) => __field,
653 _serde::__private::None => {
654 #[cfg(feature = "strict")]
655 return _serde::__private::Err(
656 <__A::Error as _serde::de::Error>::missing_field(
657 "characterId",
658 ),
659 );
660 #[cfg(not(feature = "strict"))] Default::default()
661 }
662 };
663 let m_behavior = match m_behavior {
664 _serde::__private::Some(__field) => __field,
665 _serde::__private::None => {
666 #[cfg(feature = "strict")]
667 return _serde::__private::Err(
668 <__A::Error as _serde::de::Error>::missing_field("behavior"),
669 );
670 #[cfg(not(feature = "strict"))] Default::default()
671 }
672 };
673 let m_rootGenerator = match m_rootGenerator {
674 _serde::__private::Some(__field) => __field,
675 _serde::__private::None => {
676 #[cfg(feature = "strict")]
677 return _serde::__private::Err(
678 <__A::Error as _serde::de::Error>::missing_field(
679 "rootGenerator",
680 ),
681 );
682 #[cfg(not(feature = "strict"))] Default::default()
683 }
684 };
685 let m_referencedBehaviors = match m_referencedBehaviors {
686 _serde::__private::Some(__field) => __field,
687 _serde::__private::None => {
688 #[cfg(feature = "strict")]
689 return _serde::__private::Err(
690 <__A::Error as _serde::de::Error>::missing_field(
691 "referencedBehaviors",
692 ),
693 );
694 #[cfg(not(feature = "strict"))] Default::default()
695 }
696 };
697 let m_startStateIndex = match m_startStateIndex {
698 _serde::__private::Some(__field) => __field,
699 _serde::__private::None => {
700 #[cfg(feature = "strict")]
701 return _serde::__private::Err(
702 <__A::Error as _serde::de::Error>::missing_field(
703 "startStateIndex",
704 ),
705 );
706 #[cfg(not(feature = "strict"))] Default::default()
707 }
708 };
709 let m_randomizeSimulation = match m_randomizeSimulation {
710 _serde::__private::Some(__field) => __field,
711 _serde::__private::None => {
712 #[cfg(feature = "strict")]
713 return _serde::__private::Err(
714 <__A::Error as _serde::de::Error>::missing_field(
715 "randomizeSimulation",
716 ),
717 );
718 #[cfg(not(feature = "strict"))] Default::default()
719 }
720 };
721 let m_padding = match m_padding {
722 _serde::__private::Some(__field) => __field,
723 _serde::__private::None => {
724 #[cfg(feature = "strict")]
725 return _serde::__private::Err(
726 <__A::Error as _serde::de::Error>::missing_field("padding"),
727 );
728 #[cfg(not(feature = "strict"))] Default::default()
729 }
730 };
731 let __ptr = None;
732 let parent = hkBaseObject { __ptr };
733 let parent = hkReferencedObject {
734 __ptr,
735 parent,
736 ..Default::default()
737 };
738 let __ptr = __A::class_ptr(&mut __map);
739 _serde::__private::Ok(hkbSetBehaviorCommand {
740 __ptr,
741 parent,
742 m_characterId,
743 m_behavior,
744 m_rootGenerator,
745 m_referencedBehaviors,
746 m_startStateIndex,
747 m_randomizeSimulation,
748 m_padding,
749 })
750 }
751 }
752 const FIELDS: &[&str] = &[
753 "characterId",
754 "behavior",
755 "rootGenerator",
756 "referencedBehaviors",
757 "startStateIndex",
758 "randomizeSimulation",
759 "padding",
760 ];
761 _serde::Deserializer::deserialize_struct(
762 deserializer,
763 "hkbSetBehaviorCommand",
764 FIELDS,
765 __hkbSetBehaviorCommandVisitor {
766 marker: _serde::__private::PhantomData::<hkbSetBehaviorCommand>,
767 lifetime: _serde::__private::PhantomData,
768 },
769 )
770 }
771 }
772};