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 hkpSerializedAgentNnEntry {
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 = "bodyA"))]
35 #[cfg_attr(feature = "serde", serde(rename = "bodyA"))]
36 pub m_bodyA: Pointer,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "bodyB"))]
42 #[cfg_attr(feature = "serde", serde(rename = "bodyB"))]
43 pub m_bodyB: Pointer,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "bodyAId"))]
49 #[cfg_attr(feature = "serde", serde(rename = "bodyAId"))]
50 pub m_bodyAId: Ulong,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "bodyBId"))]
56 #[cfg_attr(feature = "serde", serde(rename = "bodyBId"))]
57 pub m_bodyBId: Ulong,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "useEntityIds"))]
63 #[cfg_attr(feature = "serde", serde(rename = "useEntityIds"))]
64 pub m_useEntityIds: bool,
65 #[cfg_attr(feature = "json_schema", schemars(rename = "agentType"))]
70 #[cfg_attr(feature = "serde", serde(rename = "agentType"))]
71 pub m_agentType: SerializedAgentType,
72 #[cfg_attr(feature = "json_schema", schemars(rename = "atom"))]
77 #[cfg_attr(feature = "serde", serde(rename = "atom"))]
78 pub m_atom: hkpSimpleContactConstraintAtom,
79 #[cfg_attr(feature = "json_schema", schemars(rename = "propertiesStream"))]
84 #[cfg_attr(feature = "serde", serde(rename = "propertiesStream"))]
85 pub m_propertiesStream: Vec<u8>,
86 #[cfg_attr(feature = "json_schema", schemars(rename = "contactPoints"))]
91 #[cfg_attr(feature = "serde", serde(rename = "contactPoints"))]
92 pub m_contactPoints: Vec<hkContactPoint>,
93 #[cfg_attr(feature = "json_schema", schemars(rename = "cpIdMgr"))]
98 #[cfg_attr(feature = "serde", serde(rename = "cpIdMgr"))]
99 pub m_cpIdMgr: Vec<u8>,
100 #[cfg_attr(
105 feature = "json_schema",
106 schemars(schema_with = "make_large_int_array_schema")
107 )]
108 #[cfg_attr(
109 feature = "serde",
110 serde(with = "::serde_with::As::<[::serde_with::Same; 160]>")
111 )]
112 #[educe(Default = [0;160usize])]
113 #[cfg_attr(feature = "json_schema", schemars(rename = "nnEntryData"))]
114 #[cfg_attr(feature = "serde", serde(rename = "nnEntryData"))]
115 pub m_nnEntryData: [u8; 160usize],
116 #[cfg_attr(feature = "json_schema", schemars(rename = "trackInfo"))]
121 #[cfg_attr(feature = "serde", serde(rename = "trackInfo"))]
122 pub m_trackInfo: hkpSerializedTrack1nInfo,
123 #[cfg_attr(feature = "json_schema", schemars(rename = "endianCheckBuffer"))]
128 #[cfg_attr(feature = "serde", serde(rename = "endianCheckBuffer"))]
129 pub m_endianCheckBuffer: [u8; 4usize],
130 #[cfg_attr(feature = "json_schema", schemars(rename = "version"))]
135 #[cfg_attr(feature = "serde", serde(rename = "version"))]
136 pub m_version: u32,
137}
138const _: () = {
139 use havok_serde as _serde;
140 impl _serde::HavokClass for hkpSerializedAgentNnEntry {
141 #[inline]
142 fn name(&self) -> &'static str {
143 "hkpSerializedAgentNnEntry"
144 }
145 #[inline]
146 fn signature(&self) -> _serde::__private::Signature {
147 _serde::__private::Signature::new(0x49ec7de3)
148 }
149 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
150 fn deps_indexes(&self) -> Vec<usize> {
151 let mut v = Vec::new();
152 v.push(self.m_bodyA.get());
153 v.push(self.m_bodyB.get());
154 v.extend(self.m_atom.deps_indexes());
155 v.extend(
156 self
157 .m_contactPoints
158 .iter()
159 .flat_map(|class| class.deps_indexes())
160 .collect::<Vec<usize>>(),
161 );
162 v.extend(self.m_trackInfo.deps_indexes());
163 v
164 }
165 }
166 impl _serde::Serialize for hkpSerializedAgentNnEntry {
167 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
168 where
169 S: _serde::ser::Serializer,
170 {
171 let class_meta = self
172 .__ptr
173 .map(|name| (name, _serde::__private::Signature::new(0x49ec7de3)));
174 let mut serializer = __serializer
175 .serialize_struct(
176 "hkpSerializedAgentNnEntry",
177 class_meta,
178 (320u64, 368u64),
179 )?;
180 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
181 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
182 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
183 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
184 serializer.serialize_field("bodyA", &self.m_bodyA)?;
185 serializer.serialize_field("bodyB", &self.m_bodyB)?;
186 serializer.serialize_field("bodyAId", &self.m_bodyAId)?;
187 serializer.serialize_field("bodyBId", &self.m_bodyBId)?;
188 serializer.serialize_field("useEntityIds", &self.m_useEntityIds)?;
189 serializer.serialize_field("agentType", &self.m_agentType)?;
190 serializer.pad_field([0u8; 6usize].as_slice(), [0u8; 14usize].as_slice())?;
191 serializer.serialize_field("atom", &self.m_atom)?;
192 serializer
193 .serialize_array_field(
194 "propertiesStream",
195 &self.m_propertiesStream,
196 TypeSize::NonPtr,
197 )?;
198 serializer
199 .serialize_array_field(
200 "contactPoints",
201 &self.m_contactPoints,
202 TypeSize::Struct {
203 size_x86: 32u64,
204 size_x86_64: 32u64,
205 },
206 )?;
207 serializer
208 .serialize_array_field("cpIdMgr", &self.m_cpIdMgr, TypeSize::NonPtr)?;
209 serializer
210 .serialize_fixed_array_field(
211 "nnEntryData",
212 self.m_nnEntryData.as_slice(),
213 TypeSize::NonPtr,
214 )?;
215 serializer.serialize_field("trackInfo", &self.m_trackInfo)?;
216 serializer
217 .serialize_fixed_array_field(
218 "endianCheckBuffer",
219 self.m_endianCheckBuffer.as_slice(),
220 TypeSize::NonPtr,
221 )?;
222 serializer.serialize_field("version", &self.m_version)?;
223 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 8usize].as_slice())?;
224 serializer.end()
225 }
226 }
227};
228#[doc(hidden)]
229#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
230const _: () = {
231 use havok_serde as _serde;
232 #[automatically_derived]
233 impl<'de> _serde::Deserialize<'de> for hkpSerializedAgentNnEntry {
234 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
235 where
236 __D: _serde::Deserializer<'de>,
237 {
238 #[allow(non_camel_case_types)]
239 enum __Field {
240 m_bodyA,
241 m_bodyB,
242 m_bodyAId,
243 m_bodyBId,
244 m_useEntityIds,
245 m_agentType,
246 m_atom,
247 m_propertiesStream,
248 m_contactPoints,
249 m_cpIdMgr,
250 m_nnEntryData,
251 m_trackInfo,
252 m_endianCheckBuffer,
253 m_version,
254 __ignore,
255 }
256 struct __FieldVisitor;
257 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
258 type Value = __Field;
259 fn expecting(
260 &self,
261 __formatter: &mut core::fmt::Formatter,
262 ) -> core::fmt::Result {
263 core::fmt::Formatter::write_str(__formatter, "field identifier")
264 }
265 #[allow(clippy::match_single_binding)]
267 #[allow(clippy::reversed_empty_ranges)]
268 #[allow(clippy::single_match)]
269 fn visit_key<__E>(
270 self,
271 __value: &str,
272 ) -> core::result::Result<Self::Value, __E>
273 where
274 __E: _serde::de::Error,
275 {
276 match __value {
277 "bodyA" => Ok(__Field::m_bodyA),
278 "bodyB" => Ok(__Field::m_bodyB),
279 "bodyAId" => Ok(__Field::m_bodyAId),
280 "bodyBId" => Ok(__Field::m_bodyBId),
281 "useEntityIds" => Ok(__Field::m_useEntityIds),
282 "agentType" => Ok(__Field::m_agentType),
283 "atom" => Ok(__Field::m_atom),
284 "propertiesStream" => Ok(__Field::m_propertiesStream),
285 "contactPoints" => Ok(__Field::m_contactPoints),
286 "cpIdMgr" => Ok(__Field::m_cpIdMgr),
287 "nnEntryData" => Ok(__Field::m_nnEntryData),
288 "trackInfo" => Ok(__Field::m_trackInfo),
289 "endianCheckBuffer" => Ok(__Field::m_endianCheckBuffer),
290 "version" => Ok(__Field::m_version),
291 _ => Ok(__Field::__ignore),
292 }
293 }
294 }
295 impl<'de> _serde::Deserialize<'de> for __Field {
296 #[inline]
297 fn deserialize<__D>(
298 __deserializer: __D,
299 ) -> core::result::Result<Self, __D::Error>
300 where
301 __D: _serde::Deserializer<'de>,
302 {
303 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
304 }
305 }
306 struct __hkpSerializedAgentNnEntryVisitor<'de> {
307 marker: _serde::__private::PhantomData<hkpSerializedAgentNnEntry>,
308 lifetime: _serde::__private::PhantomData<&'de ()>,
309 }
310 #[allow(clippy::match_single_binding)]
311 #[allow(clippy::reversed_empty_ranges)]
312 #[allow(clippy::single_match)]
313 impl<'de> _serde::de::Visitor<'de>
314 for __hkpSerializedAgentNnEntryVisitor<'de> {
315 type Value = hkpSerializedAgentNnEntry;
316 fn expecting(
317 &self,
318 __formatter: &mut core::fmt::Formatter,
319 ) -> core::fmt::Result {
320 core::fmt::Formatter::write_str(
321 __formatter,
322 "struct hkpSerializedAgentNnEntry",
323 )
324 }
325 fn visit_struct_for_bytes<__A>(
326 self,
327 mut __map: __A,
328 ) -> _serde::__private::Result<Self::Value, __A::Error>
329 where
330 __A: _serde::de::MapAccess<'de>,
331 {
332 let __ptr = __A::class_ptr(&mut __map);
333 let parent = __A::parent_value(&mut __map)?;
334 let mut m_bodyA: _serde::__private::Option<Pointer> = _serde::__private::None;
335 let mut m_bodyB: _serde::__private::Option<Pointer> = _serde::__private::None;
336 let mut m_bodyAId: _serde::__private::Option<Ulong> = _serde::__private::None;
337 let mut m_bodyBId: _serde::__private::Option<Ulong> = _serde::__private::None;
338 let mut m_useEntityIds: _serde::__private::Option<bool> = _serde::__private::None;
339 let mut m_agentType: _serde::__private::Option<
340 SerializedAgentType,
341 > = _serde::__private::None;
342 let mut m_atom: _serde::__private::Option<
343 hkpSimpleContactConstraintAtom,
344 > = _serde::__private::None;
345 let mut m_propertiesStream: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
346 let mut m_contactPoints: _serde::__private::Option<
347 Vec<hkContactPoint>,
348 > = _serde::__private::None;
349 let mut m_cpIdMgr: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
350 let mut m_nnEntryData: _serde::__private::Option<[u8; 160usize]> = _serde::__private::None;
351 let mut m_trackInfo: _serde::__private::Option<
352 hkpSerializedTrack1nInfo,
353 > = _serde::__private::None;
354 let mut m_endianCheckBuffer: _serde::__private::Option<
355 [u8; 4usize],
356 > = _serde::__private::None;
357 let mut m_version: _serde::__private::Option<u32> = _serde::__private::None;
358 for i in 0..14usize {
359 match i {
360 0usize => {
361 if _serde::__private::Option::is_some(&m_bodyA) {
362 return _serde::__private::Err(
363 <__A::Error as _serde::de::Error>::duplicate_field("bodyA"),
364 );
365 }
366 m_bodyA = _serde::__private::Some(
367 match __A::next_value::<Pointer>(&mut __map) {
368 _serde::__private::Ok(__val) => __val,
369 _serde::__private::Err(__err) => {
370 return _serde::__private::Err(__err);
371 }
372 },
373 );
374 }
375 1usize => {
376 if _serde::__private::Option::is_some(&m_bodyB) {
377 return _serde::__private::Err(
378 <__A::Error as _serde::de::Error>::duplicate_field("bodyB"),
379 );
380 }
381 m_bodyB = _serde::__private::Some(
382 match __A::next_value::<Pointer>(&mut __map) {
383 _serde::__private::Ok(__val) => __val,
384 _serde::__private::Err(__err) => {
385 return _serde::__private::Err(__err);
386 }
387 },
388 );
389 }
390 2usize => {
391 if _serde::__private::Option::is_some(&m_bodyAId) {
392 return _serde::__private::Err(
393 <__A::Error as _serde::de::Error>::duplicate_field(
394 "bodyAId",
395 ),
396 );
397 }
398 m_bodyAId = _serde::__private::Some(
399 match __A::next_value::<Ulong>(&mut __map) {
400 _serde::__private::Ok(__val) => __val,
401 _serde::__private::Err(__err) => {
402 return _serde::__private::Err(__err);
403 }
404 },
405 );
406 }
407 3usize => {
408 if _serde::__private::Option::is_some(&m_bodyBId) {
409 return _serde::__private::Err(
410 <__A::Error as _serde::de::Error>::duplicate_field(
411 "bodyBId",
412 ),
413 );
414 }
415 m_bodyBId = _serde::__private::Some(
416 match __A::next_value::<Ulong>(&mut __map) {
417 _serde::__private::Ok(__val) => __val,
418 _serde::__private::Err(__err) => {
419 return _serde::__private::Err(__err);
420 }
421 },
422 );
423 }
424 4usize => {
425 if _serde::__private::Option::is_some(&m_useEntityIds) {
426 return _serde::__private::Err(
427 <__A::Error as _serde::de::Error>::duplicate_field(
428 "useEntityIds",
429 ),
430 );
431 }
432 m_useEntityIds = _serde::__private::Some(
433 match __A::next_value::<bool>(&mut __map) {
434 _serde::__private::Ok(__val) => __val,
435 _serde::__private::Err(__err) => {
436 return _serde::__private::Err(__err);
437 }
438 },
439 );
440 }
441 5usize => {
442 if _serde::__private::Option::is_some(&m_agentType) {
443 return _serde::__private::Err(
444 <__A::Error as _serde::de::Error>::duplicate_field(
445 "agentType",
446 ),
447 );
448 }
449 m_agentType = _serde::__private::Some(
450 match __A::next_value::<SerializedAgentType>(&mut __map) {
451 _serde::__private::Ok(__val) => __val,
452 _serde::__private::Err(__err) => {
453 return _serde::__private::Err(__err);
454 }
455 },
456 );
457 }
458 6usize => {
459 if _serde::__private::Option::is_some(&m_atom) {
460 return _serde::__private::Err(
461 <__A::Error as _serde::de::Error>::duplicate_field("atom"),
462 );
463 }
464 __A::pad(&mut __map, 6usize, 14usize)?;
465 m_atom = _serde::__private::Some(
466 match __A::next_value::<
467 hkpSimpleContactConstraintAtom,
468 >(&mut __map) {
469 _serde::__private::Ok(__val) => __val,
470 _serde::__private::Err(__err) => {
471 return _serde::__private::Err(__err);
472 }
473 },
474 );
475 }
476 7usize => {
477 if _serde::__private::Option::is_some(&m_propertiesStream) {
478 return _serde::__private::Err(
479 <__A::Error as _serde::de::Error>::duplicate_field(
480 "propertiesStream",
481 ),
482 );
483 }
484 m_propertiesStream = _serde::__private::Some(
485 match __A::next_value::<Vec<u8>>(&mut __map) {
486 _serde::__private::Ok(__val) => __val,
487 _serde::__private::Err(__err) => {
488 return _serde::__private::Err(__err);
489 }
490 },
491 );
492 }
493 8usize => {
494 if _serde::__private::Option::is_some(&m_contactPoints) {
495 return _serde::__private::Err(
496 <__A::Error as _serde::de::Error>::duplicate_field(
497 "contactPoints",
498 ),
499 );
500 }
501 m_contactPoints = _serde::__private::Some(
502 match __A::next_value::<Vec<hkContactPoint>>(&mut __map) {
503 _serde::__private::Ok(__val) => __val,
504 _serde::__private::Err(__err) => {
505 return _serde::__private::Err(__err);
506 }
507 },
508 );
509 }
510 9usize => {
511 if _serde::__private::Option::is_some(&m_cpIdMgr) {
512 return _serde::__private::Err(
513 <__A::Error as _serde::de::Error>::duplicate_field(
514 "cpIdMgr",
515 ),
516 );
517 }
518 m_cpIdMgr = _serde::__private::Some(
519 match __A::next_value::<Vec<u8>>(&mut __map) {
520 _serde::__private::Ok(__val) => __val,
521 _serde::__private::Err(__err) => {
522 return _serde::__private::Err(__err);
523 }
524 },
525 );
526 }
527 10usize => {
528 if _serde::__private::Option::is_some(&m_nnEntryData) {
529 return _serde::__private::Err(
530 <__A::Error as _serde::de::Error>::duplicate_field(
531 "nnEntryData",
532 ),
533 );
534 }
535 m_nnEntryData = _serde::__private::Some(
536 match __A::next_value::<[u8; 160usize]>(&mut __map) {
537 _serde::__private::Ok(__val) => __val,
538 _serde::__private::Err(__err) => {
539 return _serde::__private::Err(__err);
540 }
541 },
542 );
543 }
544 11usize => {
545 if _serde::__private::Option::is_some(&m_trackInfo) {
546 return _serde::__private::Err(
547 <__A::Error as _serde::de::Error>::duplicate_field(
548 "trackInfo",
549 ),
550 );
551 }
552 m_trackInfo = _serde::__private::Some(
553 match __A::next_value::<
554 hkpSerializedTrack1nInfo,
555 >(&mut __map) {
556 _serde::__private::Ok(__val) => __val,
557 _serde::__private::Err(__err) => {
558 return _serde::__private::Err(__err);
559 }
560 },
561 );
562 }
563 12usize => {
564 if _serde::__private::Option::is_some(
565 &m_endianCheckBuffer,
566 ) {
567 return _serde::__private::Err(
568 <__A::Error as _serde::de::Error>::duplicate_field(
569 "endianCheckBuffer",
570 ),
571 );
572 }
573 m_endianCheckBuffer = _serde::__private::Some(
574 match __A::next_value::<[u8; 4usize]>(&mut __map) {
575 _serde::__private::Ok(__val) => __val,
576 _serde::__private::Err(__err) => {
577 return _serde::__private::Err(__err);
578 }
579 },
580 );
581 }
582 13usize => {
583 if _serde::__private::Option::is_some(&m_version) {
584 return _serde::__private::Err(
585 <__A::Error as _serde::de::Error>::duplicate_field(
586 "version",
587 ),
588 );
589 }
590 m_version = _serde::__private::Some(
591 match __A::next_value::<u32>(&mut __map) {
592 _serde::__private::Ok(__val) => __val,
593 _serde::__private::Err(__err) => {
594 return _serde::__private::Err(__err);
595 }
596 },
597 );
598 }
599 _ => {}
600 }
601 }
602 __A::pad(&mut __map, 12usize, 8usize)?;
603 let m_bodyA = match m_bodyA {
604 _serde::__private::Some(__field) => __field,
605 _serde::__private::None => {
606 return _serde::__private::Err(
607 <__A::Error as _serde::de::Error>::missing_field("bodyA"),
608 );
609 }
610 };
611 let m_bodyB = match m_bodyB {
612 _serde::__private::Some(__field) => __field,
613 _serde::__private::None => {
614 return _serde::__private::Err(
615 <__A::Error as _serde::de::Error>::missing_field("bodyB"),
616 );
617 }
618 };
619 let m_bodyAId = match m_bodyAId {
620 _serde::__private::Some(__field) => __field,
621 _serde::__private::None => {
622 return _serde::__private::Err(
623 <__A::Error as _serde::de::Error>::missing_field("bodyAId"),
624 );
625 }
626 };
627 let m_bodyBId = match m_bodyBId {
628 _serde::__private::Some(__field) => __field,
629 _serde::__private::None => {
630 return _serde::__private::Err(
631 <__A::Error as _serde::de::Error>::missing_field("bodyBId"),
632 );
633 }
634 };
635 let m_useEntityIds = match m_useEntityIds {
636 _serde::__private::Some(__field) => __field,
637 _serde::__private::None => {
638 return _serde::__private::Err(
639 <__A::Error as _serde::de::Error>::missing_field(
640 "useEntityIds",
641 ),
642 );
643 }
644 };
645 let m_agentType = match m_agentType {
646 _serde::__private::Some(__field) => __field,
647 _serde::__private::None => {
648 return _serde::__private::Err(
649 <__A::Error as _serde::de::Error>::missing_field(
650 "agentType",
651 ),
652 );
653 }
654 };
655 let m_atom = match m_atom {
656 _serde::__private::Some(__field) => __field,
657 _serde::__private::None => {
658 return _serde::__private::Err(
659 <__A::Error as _serde::de::Error>::missing_field("atom"),
660 );
661 }
662 };
663 let m_propertiesStream = match m_propertiesStream {
664 _serde::__private::Some(__field) => __field,
665 _serde::__private::None => {
666 return _serde::__private::Err(
667 <__A::Error as _serde::de::Error>::missing_field(
668 "propertiesStream",
669 ),
670 );
671 }
672 };
673 let m_contactPoints = match m_contactPoints {
674 _serde::__private::Some(__field) => __field,
675 _serde::__private::None => {
676 return _serde::__private::Err(
677 <__A::Error as _serde::de::Error>::missing_field(
678 "contactPoints",
679 ),
680 );
681 }
682 };
683 let m_cpIdMgr = match m_cpIdMgr {
684 _serde::__private::Some(__field) => __field,
685 _serde::__private::None => {
686 return _serde::__private::Err(
687 <__A::Error as _serde::de::Error>::missing_field("cpIdMgr"),
688 );
689 }
690 };
691 let m_nnEntryData = match m_nnEntryData {
692 _serde::__private::Some(__field) => __field,
693 _serde::__private::None => {
694 return _serde::__private::Err(
695 <__A::Error as _serde::de::Error>::missing_field(
696 "nnEntryData",
697 ),
698 );
699 }
700 };
701 let m_trackInfo = match m_trackInfo {
702 _serde::__private::Some(__field) => __field,
703 _serde::__private::None => {
704 return _serde::__private::Err(
705 <__A::Error as _serde::de::Error>::missing_field(
706 "trackInfo",
707 ),
708 );
709 }
710 };
711 let m_endianCheckBuffer = match m_endianCheckBuffer {
712 _serde::__private::Some(__field) => __field,
713 _serde::__private::None => {
714 return _serde::__private::Err(
715 <__A::Error as _serde::de::Error>::missing_field(
716 "endianCheckBuffer",
717 ),
718 );
719 }
720 };
721 let m_version = match m_version {
722 _serde::__private::Some(__field) => __field,
723 _serde::__private::None => {
724 return _serde::__private::Err(
725 <__A::Error as _serde::de::Error>::missing_field("version"),
726 );
727 }
728 };
729 _serde::__private::Ok(hkpSerializedAgentNnEntry {
730 __ptr,
731 parent,
732 m_bodyA,
733 m_bodyB,
734 m_bodyAId,
735 m_bodyBId,
736 m_useEntityIds,
737 m_agentType,
738 m_atom,
739 m_propertiesStream,
740 m_contactPoints,
741 m_cpIdMgr,
742 m_nnEntryData,
743 m_trackInfo,
744 m_endianCheckBuffer,
745 m_version,
746 })
747 }
748 #[allow(clippy::manual_unwrap_or_default)]
749 fn visit_struct<__A>(
750 self,
751 mut __map: __A,
752 ) -> _serde::__private::Result<Self::Value, __A::Error>
753 where
754 __A: _serde::de::MapAccess<'de>,
755 {
756 let mut m_bodyA: _serde::__private::Option<Pointer> = _serde::__private::None;
757 let mut m_bodyB: _serde::__private::Option<Pointer> = _serde::__private::None;
758 let mut m_bodyAId: _serde::__private::Option<Ulong> = _serde::__private::None;
759 let mut m_bodyBId: _serde::__private::Option<Ulong> = _serde::__private::None;
760 let mut m_useEntityIds: _serde::__private::Option<bool> = _serde::__private::None;
761 let mut m_agentType: _serde::__private::Option<
762 SerializedAgentType,
763 > = _serde::__private::None;
764 let mut m_atom: _serde::__private::Option<
765 hkpSimpleContactConstraintAtom,
766 > = _serde::__private::None;
767 let mut m_propertiesStream: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
768 let mut m_contactPoints: _serde::__private::Option<
769 Vec<hkContactPoint>,
770 > = _serde::__private::None;
771 let mut m_cpIdMgr: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
772 let mut m_nnEntryData: _serde::__private::Option<[u8; 160usize]> = _serde::__private::None;
773 let mut m_trackInfo: _serde::__private::Option<
774 hkpSerializedTrack1nInfo,
775 > = _serde::__private::None;
776 let mut m_endianCheckBuffer: _serde::__private::Option<
777 [u8; 4usize],
778 > = _serde::__private::None;
779 let mut m_version: _serde::__private::Option<u32> = _serde::__private::None;
780 while let _serde::__private::Some(__key) = {
781 __A::next_key::<__Field>(&mut __map)?
782 } {
783 match __key {
784 __Field::m_bodyA => {
785 #[cfg(
786 any(feature = "strict", feature = "ignore_duplicates")
787 )]
788 if _serde::__private::Option::is_some(&m_bodyA) {
789 #[cfg(feature = "ignore_duplicates")]
790 {
791 __A::skip_value(&mut __map)?;
792 continue;
793 }
794 #[cfg(feature = "strict")]
795 return _serde::__private::Err(
796 <__A::Error as _serde::de::Error>::duplicate_field("bodyA"),
797 );
798 }
799 m_bodyA = _serde::__private::Some(
800 match __A::next_value::<Pointer>(&mut __map) {
801 _serde::__private::Ok(__val) => __val,
802 _serde::__private::Err(__err) => {
803 return _serde::__private::Err(__err);
804 }
805 },
806 );
807 }
808 __Field::m_bodyB => {
809 #[cfg(
810 any(feature = "strict", feature = "ignore_duplicates")
811 )]
812 if _serde::__private::Option::is_some(&m_bodyB) {
813 #[cfg(feature = "ignore_duplicates")]
814 {
815 __A::skip_value(&mut __map)?;
816 continue;
817 }
818 #[cfg(feature = "strict")]
819 return _serde::__private::Err(
820 <__A::Error as _serde::de::Error>::duplicate_field("bodyB"),
821 );
822 }
823 m_bodyB = _serde::__private::Some(
824 match __A::next_value::<Pointer>(&mut __map) {
825 _serde::__private::Ok(__val) => __val,
826 _serde::__private::Err(__err) => {
827 return _serde::__private::Err(__err);
828 }
829 },
830 );
831 }
832 __Field::m_bodyAId => {
833 #[cfg(
834 any(feature = "strict", feature = "ignore_duplicates")
835 )]
836 if _serde::__private::Option::is_some(&m_bodyAId) {
837 #[cfg(feature = "ignore_duplicates")]
838 {
839 __A::skip_value(&mut __map)?;
840 continue;
841 }
842 #[cfg(feature = "strict")]
843 return _serde::__private::Err(
844 <__A::Error as _serde::de::Error>::duplicate_field(
845 "bodyAId",
846 ),
847 );
848 }
849 m_bodyAId = _serde::__private::Some(
850 match __A::next_value::<Ulong>(&mut __map) {
851 _serde::__private::Ok(__val) => __val,
852 _serde::__private::Err(__err) => {
853 return _serde::__private::Err(__err);
854 }
855 },
856 );
857 }
858 __Field::m_bodyBId => {
859 #[cfg(
860 any(feature = "strict", feature = "ignore_duplicates")
861 )]
862 if _serde::__private::Option::is_some(&m_bodyBId) {
863 #[cfg(feature = "ignore_duplicates")]
864 {
865 __A::skip_value(&mut __map)?;
866 continue;
867 }
868 #[cfg(feature = "strict")]
869 return _serde::__private::Err(
870 <__A::Error as _serde::de::Error>::duplicate_field(
871 "bodyBId",
872 ),
873 );
874 }
875 m_bodyBId = _serde::__private::Some(
876 match __A::next_value::<Ulong>(&mut __map) {
877 _serde::__private::Ok(__val) => __val,
878 _serde::__private::Err(__err) => {
879 return _serde::__private::Err(__err);
880 }
881 },
882 );
883 }
884 __Field::m_useEntityIds => {
885 #[cfg(
886 any(feature = "strict", feature = "ignore_duplicates")
887 )]
888 if _serde::__private::Option::is_some(&m_useEntityIds) {
889 #[cfg(feature = "ignore_duplicates")]
890 {
891 __A::skip_value(&mut __map)?;
892 continue;
893 }
894 #[cfg(feature = "strict")]
895 return _serde::__private::Err(
896 <__A::Error as _serde::de::Error>::duplicate_field(
897 "useEntityIds",
898 ),
899 );
900 }
901 m_useEntityIds = _serde::__private::Some(
902 match __A::next_value::<bool>(&mut __map) {
903 _serde::__private::Ok(__val) => __val,
904 _serde::__private::Err(__err) => {
905 return _serde::__private::Err(__err);
906 }
907 },
908 );
909 }
910 __Field::m_agentType => {
911 #[cfg(
912 any(feature = "strict", feature = "ignore_duplicates")
913 )]
914 if _serde::__private::Option::is_some(&m_agentType) {
915 #[cfg(feature = "ignore_duplicates")]
916 {
917 __A::skip_value(&mut __map)?;
918 continue;
919 }
920 #[cfg(feature = "strict")]
921 return _serde::__private::Err(
922 <__A::Error as _serde::de::Error>::duplicate_field(
923 "agentType",
924 ),
925 );
926 }
927 m_agentType = _serde::__private::Some(
928 match __A::next_value::<SerializedAgentType>(&mut __map) {
929 _serde::__private::Ok(__val) => __val,
930 _serde::__private::Err(__err) => {
931 return _serde::__private::Err(__err);
932 }
933 },
934 );
935 }
936 __Field::m_atom => {
937 #[cfg(
938 any(feature = "strict", feature = "ignore_duplicates")
939 )]
940 if _serde::__private::Option::is_some(&m_atom) {
941 #[cfg(feature = "ignore_duplicates")]
942 {
943 __A::skip_value(&mut __map)?;
944 continue;
945 }
946 #[cfg(feature = "strict")]
947 return _serde::__private::Err(
948 <__A::Error as _serde::de::Error>::duplicate_field("atom"),
949 );
950 }
951 m_atom = _serde::__private::Some(
952 match __A::next_value::<
953 hkpSimpleContactConstraintAtom,
954 >(&mut __map) {
955 _serde::__private::Ok(__val) => __val,
956 _serde::__private::Err(__err) => {
957 return _serde::__private::Err(__err);
958 }
959 },
960 );
961 }
962 __Field::m_propertiesStream => {
963 #[cfg(
964 any(feature = "strict", feature = "ignore_duplicates")
965 )]
966 if _serde::__private::Option::is_some(&m_propertiesStream) {
967 #[cfg(feature = "ignore_duplicates")]
968 {
969 __A::skip_value(&mut __map)?;
970 continue;
971 }
972 #[cfg(feature = "strict")]
973 return _serde::__private::Err(
974 <__A::Error as _serde::de::Error>::duplicate_field(
975 "propertiesStream",
976 ),
977 );
978 }
979 m_propertiesStream = _serde::__private::Some(
980 match __A::next_value::<Vec<u8>>(&mut __map) {
981 _serde::__private::Ok(__val) => __val,
982 _serde::__private::Err(__err) => {
983 return _serde::__private::Err(__err);
984 }
985 },
986 );
987 }
988 __Field::m_contactPoints => {
989 #[cfg(
990 any(feature = "strict", feature = "ignore_duplicates")
991 )]
992 if _serde::__private::Option::is_some(&m_contactPoints) {
993 #[cfg(feature = "ignore_duplicates")]
994 {
995 __A::skip_value(&mut __map)?;
996 continue;
997 }
998 #[cfg(feature = "strict")]
999 return _serde::__private::Err(
1000 <__A::Error as _serde::de::Error>::duplicate_field(
1001 "contactPoints",
1002 ),
1003 );
1004 }
1005 m_contactPoints = _serde::__private::Some(
1006 match __A::next_value::<Vec<hkContactPoint>>(&mut __map) {
1007 _serde::__private::Ok(__val) => __val,
1008 _serde::__private::Err(__err) => {
1009 return _serde::__private::Err(__err);
1010 }
1011 },
1012 );
1013 }
1014 __Field::m_cpIdMgr => {
1015 #[cfg(
1016 any(feature = "strict", feature = "ignore_duplicates")
1017 )]
1018 if _serde::__private::Option::is_some(&m_cpIdMgr) {
1019 #[cfg(feature = "ignore_duplicates")]
1020 {
1021 __A::skip_value(&mut __map)?;
1022 continue;
1023 }
1024 #[cfg(feature = "strict")]
1025 return _serde::__private::Err(
1026 <__A::Error as _serde::de::Error>::duplicate_field(
1027 "cpIdMgr",
1028 ),
1029 );
1030 }
1031 m_cpIdMgr = _serde::__private::Some(
1032 match __A::next_value::<Vec<u8>>(&mut __map) {
1033 _serde::__private::Ok(__val) => __val,
1034 _serde::__private::Err(__err) => {
1035 return _serde::__private::Err(__err);
1036 }
1037 },
1038 );
1039 }
1040 __Field::m_nnEntryData => {
1041 #[cfg(
1042 any(feature = "strict", feature = "ignore_duplicates")
1043 )]
1044 if _serde::__private::Option::is_some(&m_nnEntryData) {
1045 #[cfg(feature = "ignore_duplicates")]
1046 {
1047 __A::skip_value(&mut __map)?;
1048 continue;
1049 }
1050 #[cfg(feature = "strict")]
1051 return _serde::__private::Err(
1052 <__A::Error as _serde::de::Error>::duplicate_field(
1053 "nnEntryData",
1054 ),
1055 );
1056 }
1057 m_nnEntryData = _serde::__private::Some(
1058 match __A::next_value::<[u8; 160usize]>(&mut __map) {
1059 _serde::__private::Ok(__val) => __val,
1060 _serde::__private::Err(__err) => {
1061 return _serde::__private::Err(__err);
1062 }
1063 },
1064 );
1065 }
1066 __Field::m_trackInfo => {
1067 #[cfg(
1068 any(feature = "strict", feature = "ignore_duplicates")
1069 )]
1070 if _serde::__private::Option::is_some(&m_trackInfo) {
1071 #[cfg(feature = "ignore_duplicates")]
1072 {
1073 __A::skip_value(&mut __map)?;
1074 continue;
1075 }
1076 #[cfg(feature = "strict")]
1077 return _serde::__private::Err(
1078 <__A::Error as _serde::de::Error>::duplicate_field(
1079 "trackInfo",
1080 ),
1081 );
1082 }
1083 m_trackInfo = _serde::__private::Some(
1084 match __A::next_value::<
1085 hkpSerializedTrack1nInfo,
1086 >(&mut __map) {
1087 _serde::__private::Ok(__val) => __val,
1088 _serde::__private::Err(__err) => {
1089 return _serde::__private::Err(__err);
1090 }
1091 },
1092 );
1093 }
1094 __Field::m_endianCheckBuffer => {
1095 #[cfg(
1096 any(feature = "strict", feature = "ignore_duplicates")
1097 )]
1098 if _serde::__private::Option::is_some(
1099 &m_endianCheckBuffer,
1100 ) {
1101 #[cfg(feature = "ignore_duplicates")]
1102 {
1103 __A::skip_value(&mut __map)?;
1104 continue;
1105 }
1106 #[cfg(feature = "strict")]
1107 return _serde::__private::Err(
1108 <__A::Error as _serde::de::Error>::duplicate_field(
1109 "endianCheckBuffer",
1110 ),
1111 );
1112 }
1113 m_endianCheckBuffer = _serde::__private::Some(
1114 match __A::next_value::<[u8; 4usize]>(&mut __map) {
1115 _serde::__private::Ok(__val) => __val,
1116 _serde::__private::Err(__err) => {
1117 return _serde::__private::Err(__err);
1118 }
1119 },
1120 );
1121 }
1122 __Field::m_version => {
1123 #[cfg(
1124 any(feature = "strict", feature = "ignore_duplicates")
1125 )]
1126 if _serde::__private::Option::is_some(&m_version) {
1127 #[cfg(feature = "ignore_duplicates")]
1128 {
1129 __A::skip_value(&mut __map)?;
1130 continue;
1131 }
1132 #[cfg(feature = "strict")]
1133 return _serde::__private::Err(
1134 <__A::Error as _serde::de::Error>::duplicate_field(
1135 "version",
1136 ),
1137 );
1138 }
1139 m_version = _serde::__private::Some(
1140 match __A::next_value::<u32>(&mut __map) {
1141 _serde::__private::Ok(__val) => __val,
1142 _serde::__private::Err(__err) => {
1143 return _serde::__private::Err(__err);
1144 }
1145 },
1146 );
1147 }
1148 _ => __A::skip_value(&mut __map)?,
1149 }
1150 }
1151 let m_bodyA = match m_bodyA {
1152 _serde::__private::Some(__field) => __field,
1153 _serde::__private::None => {
1154 #[cfg(feature = "strict")]
1155 return _serde::__private::Err(
1156 <__A::Error as _serde::de::Error>::missing_field("bodyA"),
1157 );
1158 #[cfg(not(feature = "strict"))] Default::default()
1159 }
1160 };
1161 let m_bodyB = match m_bodyB {
1162 _serde::__private::Some(__field) => __field,
1163 _serde::__private::None => {
1164 #[cfg(feature = "strict")]
1165 return _serde::__private::Err(
1166 <__A::Error as _serde::de::Error>::missing_field("bodyB"),
1167 );
1168 #[cfg(not(feature = "strict"))] Default::default()
1169 }
1170 };
1171 let m_bodyAId = match m_bodyAId {
1172 _serde::__private::Some(__field) => __field,
1173 _serde::__private::None => {
1174 #[cfg(feature = "strict")]
1175 return _serde::__private::Err(
1176 <__A::Error as _serde::de::Error>::missing_field("bodyAId"),
1177 );
1178 #[cfg(not(feature = "strict"))] Default::default()
1179 }
1180 };
1181 let m_bodyBId = match m_bodyBId {
1182 _serde::__private::Some(__field) => __field,
1183 _serde::__private::None => {
1184 #[cfg(feature = "strict")]
1185 return _serde::__private::Err(
1186 <__A::Error as _serde::de::Error>::missing_field("bodyBId"),
1187 );
1188 #[cfg(not(feature = "strict"))] Default::default()
1189 }
1190 };
1191 let m_useEntityIds = match m_useEntityIds {
1192 _serde::__private::Some(__field) => __field,
1193 _serde::__private::None => {
1194 #[cfg(feature = "strict")]
1195 return _serde::__private::Err(
1196 <__A::Error as _serde::de::Error>::missing_field(
1197 "useEntityIds",
1198 ),
1199 );
1200 #[cfg(not(feature = "strict"))] Default::default()
1201 }
1202 };
1203 let m_agentType = match m_agentType {
1204 _serde::__private::Some(__field) => __field,
1205 _serde::__private::None => {
1206 #[cfg(feature = "strict")]
1207 return _serde::__private::Err(
1208 <__A::Error as _serde::de::Error>::missing_field(
1209 "agentType",
1210 ),
1211 );
1212 #[cfg(not(feature = "strict"))] Default::default()
1213 }
1214 };
1215 let m_atom = match m_atom {
1216 _serde::__private::Some(__field) => __field,
1217 _serde::__private::None => {
1218 #[cfg(feature = "strict")]
1219 return _serde::__private::Err(
1220 <__A::Error as _serde::de::Error>::missing_field("atom"),
1221 );
1222 #[cfg(not(feature = "strict"))] Default::default()
1223 }
1224 };
1225 let m_propertiesStream = match m_propertiesStream {
1226 _serde::__private::Some(__field) => __field,
1227 _serde::__private::None => {
1228 #[cfg(feature = "strict")]
1229 return _serde::__private::Err(
1230 <__A::Error as _serde::de::Error>::missing_field(
1231 "propertiesStream",
1232 ),
1233 );
1234 #[cfg(not(feature = "strict"))] Default::default()
1235 }
1236 };
1237 let m_contactPoints = match m_contactPoints {
1238 _serde::__private::Some(__field) => __field,
1239 _serde::__private::None => {
1240 #[cfg(feature = "strict")]
1241 return _serde::__private::Err(
1242 <__A::Error as _serde::de::Error>::missing_field(
1243 "contactPoints",
1244 ),
1245 );
1246 #[cfg(not(feature = "strict"))] Default::default()
1247 }
1248 };
1249 let m_cpIdMgr = match m_cpIdMgr {
1250 _serde::__private::Some(__field) => __field,
1251 _serde::__private::None => {
1252 #[cfg(feature = "strict")]
1253 return _serde::__private::Err(
1254 <__A::Error as _serde::de::Error>::missing_field("cpIdMgr"),
1255 );
1256 #[cfg(not(feature = "strict"))] Default::default()
1257 }
1258 };
1259 let m_nnEntryData = match m_nnEntryData {
1260 _serde::__private::Some(__field) => __field,
1261 _serde::__private::None => {
1262 #[cfg(feature = "strict")]
1263 return _serde::__private::Err(
1264 <__A::Error as _serde::de::Error>::missing_field(
1265 "nnEntryData",
1266 ),
1267 );
1268 #[cfg(not(feature = "strict"))]
1269 [Default::default(); 160usize]
1270 }
1271 };
1272 let m_trackInfo = match m_trackInfo {
1273 _serde::__private::Some(__field) => __field,
1274 _serde::__private::None => {
1275 #[cfg(feature = "strict")]
1276 return _serde::__private::Err(
1277 <__A::Error as _serde::de::Error>::missing_field(
1278 "trackInfo",
1279 ),
1280 );
1281 #[cfg(not(feature = "strict"))] Default::default()
1282 }
1283 };
1284 let m_endianCheckBuffer = match m_endianCheckBuffer {
1285 _serde::__private::Some(__field) => __field,
1286 _serde::__private::None => {
1287 #[cfg(feature = "strict")]
1288 return _serde::__private::Err(
1289 <__A::Error as _serde::de::Error>::missing_field(
1290 "endianCheckBuffer",
1291 ),
1292 );
1293 #[cfg(not(feature = "strict"))] Default::default()
1294 }
1295 };
1296 let m_version = match m_version {
1297 _serde::__private::Some(__field) => __field,
1298 _serde::__private::None => {
1299 #[cfg(feature = "strict")]
1300 return _serde::__private::Err(
1301 <__A::Error as _serde::de::Error>::missing_field("version"),
1302 );
1303 #[cfg(not(feature = "strict"))] Default::default()
1304 }
1305 };
1306 let __ptr = None;
1307 let parent = hkBaseObject { __ptr };
1308 let parent = hkReferencedObject {
1309 __ptr,
1310 parent,
1311 ..Default::default()
1312 };
1313 let __ptr = __A::class_ptr(&mut __map);
1314 _serde::__private::Ok(hkpSerializedAgentNnEntry {
1315 __ptr,
1316 parent,
1317 m_bodyA,
1318 m_bodyB,
1319 m_bodyAId,
1320 m_bodyBId,
1321 m_useEntityIds,
1322 m_agentType,
1323 m_atom,
1324 m_propertiesStream,
1325 m_contactPoints,
1326 m_cpIdMgr,
1327 m_nnEntryData,
1328 m_trackInfo,
1329 m_endianCheckBuffer,
1330 m_version,
1331 })
1332 }
1333 }
1334 const FIELDS: &[&str] = &[
1335 "bodyA",
1336 "bodyB",
1337 "bodyAId",
1338 "bodyBId",
1339 "useEntityIds",
1340 "agentType",
1341 "atom",
1342 "propertiesStream",
1343 "contactPoints",
1344 "cpIdMgr",
1345 "nnEntryData",
1346 "trackInfo",
1347 "endianCheckBuffer",
1348 "version",
1349 ];
1350 _serde::Deserializer::deserialize_struct(
1351 deserializer,
1352 "hkpSerializedAgentNnEntry",
1353 FIELDS,
1354 __hkpSerializedAgentNnEntryVisitor {
1355 marker: _serde::__private::PhantomData::<hkpSerializedAgentNnEntry>,
1356 lifetime: _serde::__private::PhantomData,
1357 },
1358 )
1359 }
1360 }
1361};
1362#[allow(non_upper_case_globals, non_snake_case)]
1365#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1366#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1367#[derive(
1368 Debug,
1369 Clone,
1370 Default,
1371 PartialEq,
1372 Eq,
1373 PartialOrd,
1374 Ord,
1375 num_derive::ToPrimitive,
1376 num_derive::FromPrimitive,
1377)]
1378pub enum SerializedAgentType {
1379 #[default]
1380 INVALID_AGENT_TYPE = 0isize,
1381 BOX_BOX_AGENT3 = 1isize,
1382 CAPSULE_TRIANGLE_AGENT3 = 2isize,
1383 PRED_GSK_AGENT3 = 3isize,
1384 PRED_GSK_CYLINDER_AGENT3 = 4isize,
1385 CONVEX_LIST_AGENT3 = 5isize,
1386 LIST_AGENT3 = 6isize,
1387 BV_TREE_AGENT3 = 7isize,
1388 COLLECTION_COLLECTION_AGENT3 = 8isize,
1389 COLLECTION_AGENT3 = 9isize,
1390}
1391const _: () = {
1392 use havok_serde as __serde;
1393 impl __serde::Serialize for SerializedAgentType {
1394 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1395 where
1396 S: __serde::ser::Serializer,
1397 {
1398 let mut __serializer = __serializer.serialize_enum_flags()?;
1399 match self {
1400 Self::INVALID_AGENT_TYPE => {
1401 __serializer.serialize_field("INVALID_AGENT_TYPE", &0u64)
1402 }
1403 Self::BOX_BOX_AGENT3 => {
1404 __serializer.serialize_field("BOX_BOX_AGENT3", &1u64)
1405 }
1406 Self::CAPSULE_TRIANGLE_AGENT3 => {
1407 __serializer.serialize_field("CAPSULE_TRIANGLE_AGENT3", &2u64)
1408 }
1409 Self::PRED_GSK_AGENT3 => {
1410 __serializer.serialize_field("PRED_GSK_AGENT3", &3u64)
1411 }
1412 Self::PRED_GSK_CYLINDER_AGENT3 => {
1413 __serializer.serialize_field("PRED_GSK_CYLINDER_AGENT3", &4u64)
1414 }
1415 Self::CONVEX_LIST_AGENT3 => {
1416 __serializer.serialize_field("CONVEX_LIST_AGENT3", &5u64)
1417 }
1418 Self::LIST_AGENT3 => __serializer.serialize_field("LIST_AGENT3", &6u64),
1419 Self::BV_TREE_AGENT3 => {
1420 __serializer.serialize_field("BV_TREE_AGENT3", &7u64)
1421 }
1422 Self::COLLECTION_COLLECTION_AGENT3 => {
1423 __serializer.serialize_field("COLLECTION_COLLECTION_AGENT3", &8u64)
1424 }
1425 Self::COLLECTION_AGENT3 => {
1426 __serializer.serialize_field("COLLECTION_AGENT3", &9u64)
1427 }
1428 }?;
1429 use num_traits::ToPrimitive as _;
1430 let num = self
1431 .to_i8()
1432 .ok_or(S::Error::custom("Failed enum SerializedAgentType to_i8"))?;
1433 __serializer.serialize_bits(&num)?;
1434 __serializer.end()
1435 }
1436 }
1437};
1438#[doc(hidden)]
1439#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1440const _: () = {
1441 #[allow(unused_extern_crates, clippy::useless_attribute)]
1442 extern crate havok_serde as _serde;
1443 #[automatically_derived]
1444 impl<'de> _serde::Deserialize<'de> for SerializedAgentType {
1445 fn deserialize<__D>(
1446 __deserializer: __D,
1447 ) -> _serde::__private::Result<Self, __D::Error>
1448 where
1449 __D: _serde::Deserializer<'de>,
1450 {
1451 #[allow(non_camel_case_types)]
1452 #[doc(hidden)]
1453 enum __Field {
1454 __field0,
1455 __field1,
1456 __field2,
1457 __field3,
1458 __field4,
1459 __field5,
1460 __field6,
1461 __field7,
1462 __field8,
1463 __field9,
1464 }
1465 #[doc(hidden)]
1466 struct __FieldVisitor;
1467 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1468 type Value = __Field;
1469 fn expecting(
1470 &self,
1471 __formatter: &mut _serde::__private::Formatter,
1472 ) -> _serde::__private::fmt::Result {
1473 _serde::__private::Formatter::write_str(
1474 __formatter,
1475 "variant identifier",
1476 )
1477 }
1478 fn visit_int8<__E>(
1479 self,
1480 __value: i8,
1481 ) -> _serde::__private::Result<Self::Value, __E>
1482 where
1483 __E: _serde::de::Error,
1484 {
1485 match __value {
1486 0i8 => _serde::__private::Ok(__Field::__field0),
1487 1i8 => _serde::__private::Ok(__Field::__field1),
1488 2i8 => _serde::__private::Ok(__Field::__field2),
1489 3i8 => _serde::__private::Ok(__Field::__field3),
1490 4i8 => _serde::__private::Ok(__Field::__field4),
1491 5i8 => _serde::__private::Ok(__Field::__field5),
1492 6i8 => _serde::__private::Ok(__Field::__field6),
1493 7i8 => _serde::__private::Ok(__Field::__field7),
1494 8i8 => _serde::__private::Ok(__Field::__field8),
1495 9i8 => _serde::__private::Ok(__Field::__field9),
1496 _ => {
1497 _serde::__private::Err(
1498 _serde::de::Error::invalid_value(
1499 _serde::de::Unexpected::Int8(__value),
1500 &"value(i8) of variant is one of 0, 1, 2, 3, 4, 5, 6, 7, 8, 9",
1501 ),
1502 )
1503 }
1504 }
1505 }
1506 fn visit_stringptr<__E>(
1507 self,
1508 __value: StringPtr<'de>,
1509 ) -> _serde::__private::Result<Self::Value, __E>
1510 where
1511 __E: _serde::de::Error,
1512 {
1513 if let Some(__value) = __value.into_inner() {
1514 match __value.as_ref() {
1515 v if v == "0"
1516 || v.eq_ignore_ascii_case("INVALID_AGENT_TYPE") => {
1517 _serde::__private::Ok(__Field::__field0)
1518 }
1519 v if v == "1" || v.eq_ignore_ascii_case("BOX_BOX_AGENT3") => {
1520 _serde::__private::Ok(__Field::__field1)
1521 }
1522 v if v == "2"
1523 || v.eq_ignore_ascii_case("CAPSULE_TRIANGLE_AGENT3") => {
1524 _serde::__private::Ok(__Field::__field2)
1525 }
1526 v if v == "3"
1527 || v.eq_ignore_ascii_case("PRED_GSK_AGENT3") => {
1528 _serde::__private::Ok(__Field::__field3)
1529 }
1530 v if v == "4"
1531 || v.eq_ignore_ascii_case("PRED_GSK_CYLINDER_AGENT3") => {
1532 _serde::__private::Ok(__Field::__field4)
1533 }
1534 v if v == "5"
1535 || v.eq_ignore_ascii_case("CONVEX_LIST_AGENT3") => {
1536 _serde::__private::Ok(__Field::__field5)
1537 }
1538 v if v == "6" || v.eq_ignore_ascii_case("LIST_AGENT3") => {
1539 _serde::__private::Ok(__Field::__field6)
1540 }
1541 v if v == "7" || v.eq_ignore_ascii_case("BV_TREE_AGENT3") => {
1542 _serde::__private::Ok(__Field::__field7)
1543 }
1544 v if v == "8"
1545 || v
1546 .eq_ignore_ascii_case("COLLECTION_COLLECTION_AGENT3") => {
1547 _serde::__private::Ok(__Field::__field8)
1548 }
1549 v if v == "9"
1550 || v.eq_ignore_ascii_case("COLLECTION_AGENT3") => {
1551 _serde::__private::Ok(__Field::__field9)
1552 }
1553 _ => {
1554 _serde::__private::Err(
1555 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1556 )
1557 }
1558 }
1559 } else {
1560 _serde::__private::Err(
1561 _serde::de::Error::unknown_variant("None", VARIANTS),
1562 )
1563 }
1564 }
1565 }
1566 impl<'de> _serde::Deserialize<'de> for __Field {
1567 #[inline]
1568 fn deserialize<__D>(
1569 __deserializer: __D,
1570 ) -> _serde::__private::Result<Self, __D::Error>
1571 where
1572 __D: _serde::Deserializer<'de>,
1573 {
1574 _serde::Deserializer::deserialize_identifier(
1575 __deserializer,
1576 _serde::de::ReadEnumSize::Int8,
1577 __FieldVisitor,
1578 )
1579 }
1580 }
1581 #[doc(hidden)]
1582 struct __Visitor<'de> {
1583 marker: _serde::__private::PhantomData<SerializedAgentType>,
1584 lifetime: _serde::__private::PhantomData<&'de ()>,
1585 }
1586 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1587 type Value = SerializedAgentType;
1588 fn expecting(
1589 &self,
1590 __formatter: &mut _serde::__private::Formatter,
1591 ) -> _serde::__private::fmt::Result {
1592 _serde::__private::Formatter::write_str(
1593 __formatter,
1594 "enum SerializedAgentType",
1595 )
1596 }
1597 fn visit_enum<__A>(
1598 self,
1599 __data: __A,
1600 ) -> _serde::__private::Result<Self::Value, __A::Error>
1601 where
1602 __A: _serde::de::EnumAccess<'de>,
1603 {
1604 match _serde::de::EnumAccess::variant(__data)? {
1605 (__Field::__field0, __variant) => {
1606 _serde::de::VariantAccess::unit_variant(__variant)?;
1607 _serde::__private::Ok(
1608 SerializedAgentType::INVALID_AGENT_TYPE,
1609 )
1610 }
1611 (__Field::__field1, __variant) => {
1612 _serde::de::VariantAccess::unit_variant(__variant)?;
1613 _serde::__private::Ok(SerializedAgentType::BOX_BOX_AGENT3)
1614 }
1615 (__Field::__field2, __variant) => {
1616 _serde::de::VariantAccess::unit_variant(__variant)?;
1617 _serde::__private::Ok(
1618 SerializedAgentType::CAPSULE_TRIANGLE_AGENT3,
1619 )
1620 }
1621 (__Field::__field3, __variant) => {
1622 _serde::de::VariantAccess::unit_variant(__variant)?;
1623 _serde::__private::Ok(SerializedAgentType::PRED_GSK_AGENT3)
1624 }
1625 (__Field::__field4, __variant) => {
1626 _serde::de::VariantAccess::unit_variant(__variant)?;
1627 _serde::__private::Ok(
1628 SerializedAgentType::PRED_GSK_CYLINDER_AGENT3,
1629 )
1630 }
1631 (__Field::__field5, __variant) => {
1632 _serde::de::VariantAccess::unit_variant(__variant)?;
1633 _serde::__private::Ok(
1634 SerializedAgentType::CONVEX_LIST_AGENT3,
1635 )
1636 }
1637 (__Field::__field6, __variant) => {
1638 _serde::de::VariantAccess::unit_variant(__variant)?;
1639 _serde::__private::Ok(SerializedAgentType::LIST_AGENT3)
1640 }
1641 (__Field::__field7, __variant) => {
1642 _serde::de::VariantAccess::unit_variant(__variant)?;
1643 _serde::__private::Ok(SerializedAgentType::BV_TREE_AGENT3)
1644 }
1645 (__Field::__field8, __variant) => {
1646 _serde::de::VariantAccess::unit_variant(__variant)?;
1647 _serde::__private::Ok(
1648 SerializedAgentType::COLLECTION_COLLECTION_AGENT3,
1649 )
1650 }
1651 (__Field::__field9, __variant) => {
1652 _serde::de::VariantAccess::unit_variant(__variant)?;
1653 _serde::__private::Ok(SerializedAgentType::COLLECTION_AGENT3)
1654 }
1655 }
1656 }
1657 }
1658 #[doc(hidden)]
1659 const VARIANTS: &'static [&'static str] = &[
1660 "INVALID_AGENT_TYPE",
1661 "BOX_BOX_AGENT3",
1662 "CAPSULE_TRIANGLE_AGENT3",
1663 "PRED_GSK_AGENT3",
1664 "PRED_GSK_CYLINDER_AGENT3",
1665 "CONVEX_LIST_AGENT3",
1666 "LIST_AGENT3",
1667 "BV_TREE_AGENT3",
1668 "COLLECTION_COLLECTION_AGENT3",
1669 "COLLECTION_AGENT3",
1670 ];
1671 _serde::Deserializer::deserialize_enum(
1672 __deserializer,
1673 "SerializedAgentType",
1674 VARIANTS,
1675 __Visitor {
1676 marker: _serde::__private::PhantomData::<SerializedAgentType>,
1677 lifetime: _serde::__private::PhantomData,
1678 },
1679 )
1680 }
1681 }
1682};