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