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 hkbAttachmentModifier<'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 #[cfg_attr(feature = "serde", serde(borrow))]
30 pub parent: hkbModifier<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "sendToAttacherOnAttach"))]
36 #[cfg_attr(feature = "serde", serde(rename = "sendToAttacherOnAttach"))]
37 pub m_sendToAttacherOnAttach: hkbEventProperty,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "sendToAttacheeOnAttach"))]
43 #[cfg_attr(feature = "serde", serde(rename = "sendToAttacheeOnAttach"))]
44 pub m_sendToAttacheeOnAttach: hkbEventProperty,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "sendToAttacherOnDetach"))]
50 #[cfg_attr(feature = "serde", serde(rename = "sendToAttacherOnDetach"))]
51 pub m_sendToAttacherOnDetach: hkbEventProperty,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "sendToAttacheeOnDetach"))]
57 #[cfg_attr(feature = "serde", serde(rename = "sendToAttacheeOnDetach"))]
58 pub m_sendToAttacheeOnDetach: hkbEventProperty,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "attachmentSetup"))]
64 #[cfg_attr(feature = "serde", serde(rename = "attachmentSetup"))]
65 pub m_attachmentSetup: Pointer,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "attacherHandle"))]
71 #[cfg_attr(feature = "serde", serde(rename = "attacherHandle"))]
72 pub m_attacherHandle: Pointer,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "attacheeHandle"))]
78 #[cfg_attr(feature = "serde", serde(rename = "attacheeHandle"))]
79 pub m_attacheeHandle: Pointer,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "attacheeLayer"))]
85 #[cfg_attr(feature = "serde", serde(rename = "attacheeLayer"))]
86 pub m_attacheeLayer: i32,
87 #[cfg_attr(feature = "json_schema", schemars(rename = "attacheeRB"))]
93 #[cfg_attr(feature = "serde", serde(rename = "attacheeRB"))]
94 pub m_attacheeRB: Pointer,
95 #[cfg_attr(feature = "json_schema", schemars(rename = "oldMotionType"))]
101 #[cfg_attr(feature = "serde", serde(rename = "oldMotionType"))]
102 pub m_oldMotionType: u8,
103 #[cfg_attr(feature = "json_schema", schemars(rename = "oldFilterInfo"))]
109 #[cfg_attr(feature = "serde", serde(rename = "oldFilterInfo"))]
110 pub m_oldFilterInfo: i32,
111 #[cfg_attr(feature = "json_schema", schemars(rename = "attachment"))]
117 #[cfg_attr(feature = "serde", serde(rename = "attachment"))]
118 pub m_attachment: Pointer,
119}
120const _: () = {
121 use havok_serde as _serde;
122 impl<'a> _serde::HavokClass for hkbAttachmentModifier<'a> {
123 #[inline]
124 fn name(&self) -> &'static str {
125 "hkbAttachmentModifier"
126 }
127 #[inline]
128 fn signature(&self) -> _serde::__private::Signature {
129 _serde::__private::Signature::new(0xcc0aab32)
130 }
131 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
132 fn deps_indexes(&self) -> Vec<usize> {
133 let mut v = Vec::new();
134 v.push(self.parent.parent.parent.m_variableBindingSet.get());
135 v.extend(self.m_sendToAttacherOnAttach.deps_indexes());
136 v.extend(self.m_sendToAttacheeOnAttach.deps_indexes());
137 v.extend(self.m_sendToAttacherOnDetach.deps_indexes());
138 v.extend(self.m_sendToAttacheeOnDetach.deps_indexes());
139 v.push(self.m_attachmentSetup.get());
140 v.push(self.m_attacherHandle.get());
141 v.push(self.m_attacheeHandle.get());
142 v.push(self.m_attacheeRB.get());
143 v.push(self.m_attachment.get());
144 v
145 }
146 }
147 impl<'a> _serde::Serialize for hkbAttachmentModifier<'a> {
148 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
149 where
150 S: _serde::ser::Serializer,
151 {
152 let class_meta = self
153 .__ptr
154 .map(|name| (name, _serde::__private::Signature::new(0xcc0aab32)));
155 let mut serializer = __serializer
156 .serialize_struct(
157 "hkbAttachmentModifier",
158 class_meta,
159 (108u64, 200u64),
160 )?;
161 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
162 serializer
163 .skip_field(
164 "memSizeAndFlags",
165 &self.parent.parent.parent.parent.m_memSizeAndFlags,
166 )?;
167 serializer
168 .skip_field(
169 "referenceCount",
170 &self.parent.parent.parent.parent.m_referenceCount,
171 )?;
172 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
173 serializer
174 .serialize_field(
175 "variableBindingSet",
176 &self.parent.parent.parent.m_variableBindingSet,
177 )?;
178 serializer
179 .skip_array_field(
180 "cachedBindables",
181 &self.parent.parent.parent.m_cachedBindables,
182 TypeSize::NonPtr,
183 )?;
184 serializer
185 .skip_field(
186 "areBindablesCached",
187 &self.parent.parent.parent.m_areBindablesCached,
188 )?;
189 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
190 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
191 serializer.serialize_field("name", &self.parent.parent.m_name)?;
192 serializer.skip_field("id", &self.parent.parent.m_id)?;
193 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
194 serializer
195 .skip_fixed_array_field(
196 "padNode",
197 self.parent.parent.m_padNode.as_slice(),
198 TypeSize::NonPtr,
199 )?;
200 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
201 serializer.serialize_field("enable", &self.parent.m_enable)?;
202 serializer
203 .skip_fixed_array_field(
204 "padModifier",
205 self.parent.m_padModifier.as_slice(),
206 TypeSize::NonPtr,
207 )?;
208 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
209 serializer
210 .serialize_field(
211 "sendToAttacherOnAttach",
212 &self.m_sendToAttacherOnAttach,
213 )?;
214 serializer
215 .serialize_field(
216 "sendToAttacheeOnAttach",
217 &self.m_sendToAttacheeOnAttach,
218 )?;
219 serializer
220 .serialize_field(
221 "sendToAttacherOnDetach",
222 &self.m_sendToAttacherOnDetach,
223 )?;
224 serializer
225 .serialize_field(
226 "sendToAttacheeOnDetach",
227 &self.m_sendToAttacheeOnDetach,
228 )?;
229 serializer.serialize_field("attachmentSetup", &self.m_attachmentSetup)?;
230 serializer.serialize_field("attacherHandle", &self.m_attacherHandle)?;
231 serializer.serialize_field("attacheeHandle", &self.m_attacheeHandle)?;
232 serializer.serialize_field("attacheeLayer", &self.m_attacheeLayer)?;
233 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
234 serializer.skip_field("attacheeRB", &self.m_attacheeRB)?;
235 serializer.skip_field("oldMotionType", &self.m_oldMotionType)?;
236 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
237 serializer.skip_field("oldFilterInfo", &self.m_oldFilterInfo)?;
238 serializer.skip_field("attachment", &self.m_attachment)?;
239 serializer.end()
240 }
241 }
242};
243#[doc(hidden)]
244#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
245const _: () = {
246 use havok_serde as _serde;
247 #[automatically_derived]
248 impl<'de> _serde::Deserialize<'de> for hkbAttachmentModifier<'de> {
249 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
250 where
251 __D: _serde::Deserializer<'de>,
252 {
253 #[allow(non_camel_case_types)]
254 enum __Field {
255 m_variableBindingSet,
256 m_userData,
257 m_name,
258 m_enable,
259 m_sendToAttacherOnAttach,
260 m_sendToAttacheeOnAttach,
261 m_sendToAttacherOnDetach,
262 m_sendToAttacheeOnDetach,
263 m_attachmentSetup,
264 m_attacherHandle,
265 m_attacheeHandle,
266 m_attacheeLayer,
267 __ignore,
268 }
269 struct __FieldVisitor;
270 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
271 type Value = __Field;
272 fn expecting(
273 &self,
274 __formatter: &mut core::fmt::Formatter,
275 ) -> core::fmt::Result {
276 core::fmt::Formatter::write_str(__formatter, "field identifier")
277 }
278 #[allow(clippy::match_single_binding)]
280 #[allow(clippy::reversed_empty_ranges)]
281 #[allow(clippy::single_match)]
282 fn visit_key<__E>(
283 self,
284 __value: &str,
285 ) -> core::result::Result<Self::Value, __E>
286 where
287 __E: _serde::de::Error,
288 {
289 match __value {
290 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
291 "userData" => Ok(__Field::m_userData),
292 "name" => Ok(__Field::m_name),
293 "enable" => Ok(__Field::m_enable),
294 "sendToAttacherOnAttach" => Ok(__Field::m_sendToAttacherOnAttach),
295 "sendToAttacheeOnAttach" => Ok(__Field::m_sendToAttacheeOnAttach),
296 "sendToAttacherOnDetach" => Ok(__Field::m_sendToAttacherOnDetach),
297 "sendToAttacheeOnDetach" => Ok(__Field::m_sendToAttacheeOnDetach),
298 "attachmentSetup" => Ok(__Field::m_attachmentSetup),
299 "attacherHandle" => Ok(__Field::m_attacherHandle),
300 "attacheeHandle" => Ok(__Field::m_attacheeHandle),
301 "attacheeLayer" => Ok(__Field::m_attacheeLayer),
302 _ => Ok(__Field::__ignore),
303 }
304 }
305 }
306 impl<'de> _serde::Deserialize<'de> for __Field {
307 #[inline]
308 fn deserialize<__D>(
309 __deserializer: __D,
310 ) -> core::result::Result<Self, __D::Error>
311 where
312 __D: _serde::Deserializer<'de>,
313 {
314 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
315 }
316 }
317 struct __hkbAttachmentModifierVisitor<'de> {
318 marker: _serde::__private::PhantomData<hkbAttachmentModifier<'de>>,
319 lifetime: _serde::__private::PhantomData<&'de ()>,
320 }
321 #[allow(clippy::match_single_binding)]
322 #[allow(clippy::reversed_empty_ranges)]
323 #[allow(clippy::single_match)]
324 impl<'de> _serde::de::Visitor<'de> for __hkbAttachmentModifierVisitor<'de> {
325 type Value = hkbAttachmentModifier<'de>;
326 fn expecting(
327 &self,
328 __formatter: &mut core::fmt::Formatter,
329 ) -> core::fmt::Result {
330 core::fmt::Formatter::write_str(
331 __formatter,
332 "struct hkbAttachmentModifier",
333 )
334 }
335 fn visit_struct_for_bytes<__A>(
336 self,
337 mut __map: __A,
338 ) -> _serde::__private::Result<Self::Value, __A::Error>
339 where
340 __A: _serde::de::MapAccess<'de>,
341 {
342 let __ptr = __A::class_ptr(&mut __map);
343 let parent = __A::parent_value(&mut __map)?;
344 let mut m_sendToAttacherOnAttach: _serde::__private::Option<
345 hkbEventProperty,
346 > = _serde::__private::None;
347 let mut m_sendToAttacheeOnAttach: _serde::__private::Option<
348 hkbEventProperty,
349 > = _serde::__private::None;
350 let mut m_sendToAttacherOnDetach: _serde::__private::Option<
351 hkbEventProperty,
352 > = _serde::__private::None;
353 let mut m_sendToAttacheeOnDetach: _serde::__private::Option<
354 hkbEventProperty,
355 > = _serde::__private::None;
356 let mut m_attachmentSetup: _serde::__private::Option<Pointer> = _serde::__private::None;
357 let mut m_attacherHandle: _serde::__private::Option<Pointer> = _serde::__private::None;
358 let mut m_attacheeHandle: _serde::__private::Option<Pointer> = _serde::__private::None;
359 let mut m_attacheeLayer: _serde::__private::Option<i32> = _serde::__private::None;
360 let mut m_attacheeRB: _serde::__private::Option<Pointer> = _serde::__private::None;
361 let mut m_oldMotionType: _serde::__private::Option<u8> = _serde::__private::None;
362 let mut m_oldFilterInfo: _serde::__private::Option<i32> = _serde::__private::None;
363 let mut m_attachment: _serde::__private::Option<Pointer> = _serde::__private::None;
364 for i in 0..12usize {
365 match i {
366 0usize => {
367 if _serde::__private::Option::is_some(
368 &m_sendToAttacherOnAttach,
369 ) {
370 return _serde::__private::Err(
371 <__A::Error as _serde::de::Error>::duplicate_field(
372 "sendToAttacherOnAttach",
373 ),
374 );
375 }
376 m_sendToAttacherOnAttach = _serde::__private::Some(
377 match __A::next_value::<hkbEventProperty>(&mut __map) {
378 _serde::__private::Ok(__val) => __val,
379 _serde::__private::Err(__err) => {
380 return _serde::__private::Err(__err);
381 }
382 },
383 );
384 }
385 1usize => {
386 if _serde::__private::Option::is_some(
387 &m_sendToAttacheeOnAttach,
388 ) {
389 return _serde::__private::Err(
390 <__A::Error as _serde::de::Error>::duplicate_field(
391 "sendToAttacheeOnAttach",
392 ),
393 );
394 }
395 m_sendToAttacheeOnAttach = _serde::__private::Some(
396 match __A::next_value::<hkbEventProperty>(&mut __map) {
397 _serde::__private::Ok(__val) => __val,
398 _serde::__private::Err(__err) => {
399 return _serde::__private::Err(__err);
400 }
401 },
402 );
403 }
404 2usize => {
405 if _serde::__private::Option::is_some(
406 &m_sendToAttacherOnDetach,
407 ) {
408 return _serde::__private::Err(
409 <__A::Error as _serde::de::Error>::duplicate_field(
410 "sendToAttacherOnDetach",
411 ),
412 );
413 }
414 m_sendToAttacherOnDetach = _serde::__private::Some(
415 match __A::next_value::<hkbEventProperty>(&mut __map) {
416 _serde::__private::Ok(__val) => __val,
417 _serde::__private::Err(__err) => {
418 return _serde::__private::Err(__err);
419 }
420 },
421 );
422 }
423 3usize => {
424 if _serde::__private::Option::is_some(
425 &m_sendToAttacheeOnDetach,
426 ) {
427 return _serde::__private::Err(
428 <__A::Error as _serde::de::Error>::duplicate_field(
429 "sendToAttacheeOnDetach",
430 ),
431 );
432 }
433 m_sendToAttacheeOnDetach = _serde::__private::Some(
434 match __A::next_value::<hkbEventProperty>(&mut __map) {
435 _serde::__private::Ok(__val) => __val,
436 _serde::__private::Err(__err) => {
437 return _serde::__private::Err(__err);
438 }
439 },
440 );
441 }
442 4usize => {
443 if _serde::__private::Option::is_some(&m_attachmentSetup) {
444 return _serde::__private::Err(
445 <__A::Error as _serde::de::Error>::duplicate_field(
446 "attachmentSetup",
447 ),
448 );
449 }
450 m_attachmentSetup = _serde::__private::Some(
451 match __A::next_value::<Pointer>(&mut __map) {
452 _serde::__private::Ok(__val) => __val,
453 _serde::__private::Err(__err) => {
454 return _serde::__private::Err(__err);
455 }
456 },
457 );
458 }
459 5usize => {
460 if _serde::__private::Option::is_some(&m_attacherHandle) {
461 return _serde::__private::Err(
462 <__A::Error as _serde::de::Error>::duplicate_field(
463 "attacherHandle",
464 ),
465 );
466 }
467 m_attacherHandle = _serde::__private::Some(
468 match __A::next_value::<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 6usize => {
477 if _serde::__private::Option::is_some(&m_attacheeHandle) {
478 return _serde::__private::Err(
479 <__A::Error as _serde::de::Error>::duplicate_field(
480 "attacheeHandle",
481 ),
482 );
483 }
484 m_attacheeHandle = _serde::__private::Some(
485 match __A::next_value::<Pointer>(&mut __map) {
486 _serde::__private::Ok(__val) => __val,
487 _serde::__private::Err(__err) => {
488 return _serde::__private::Err(__err);
489 }
490 },
491 );
492 }
493 7usize => {
494 if _serde::__private::Option::is_some(&m_attacheeLayer) {
495 return _serde::__private::Err(
496 <__A::Error as _serde::de::Error>::duplicate_field(
497 "attacheeLayer",
498 ),
499 );
500 }
501 m_attacheeLayer = _serde::__private::Some(
502 match __A::next_value::<i32>(&mut __map) {
503 _serde::__private::Ok(__val) => __val,
504 _serde::__private::Err(__err) => {
505 return _serde::__private::Err(__err);
506 }
507 },
508 );
509 }
510 8usize => {
511 if _serde::__private::Option::is_some(&m_attacheeRB) {
512 return _serde::__private::Err(
513 <__A::Error as _serde::de::Error>::duplicate_field(
514 "attacheeRB",
515 ),
516 );
517 }
518 __A::pad(&mut __map, 0usize, 4usize)?;
519 m_attacheeRB = _serde::__private::Some(
520 match __A::next_value::<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 9usize => {
529 if _serde::__private::Option::is_some(&m_oldMotionType) {
530 return _serde::__private::Err(
531 <__A::Error as _serde::de::Error>::duplicate_field(
532 "oldMotionType",
533 ),
534 );
535 }
536 m_oldMotionType = _serde::__private::Some(
537 match __A::next_value::<u8>(&mut __map) {
538 _serde::__private::Ok(__val) => __val,
539 _serde::__private::Err(__err) => {
540 return _serde::__private::Err(__err);
541 }
542 },
543 );
544 }
545 10usize => {
546 if _serde::__private::Option::is_some(&m_oldFilterInfo) {
547 return _serde::__private::Err(
548 <__A::Error as _serde::de::Error>::duplicate_field(
549 "oldFilterInfo",
550 ),
551 );
552 }
553 __A::pad(&mut __map, 3usize, 3usize)?;
554 m_oldFilterInfo = _serde::__private::Some(
555 match __A::next_value::<i32>(&mut __map) {
556 _serde::__private::Ok(__val) => __val,
557 _serde::__private::Err(__err) => {
558 return _serde::__private::Err(__err);
559 }
560 },
561 );
562 }
563 11usize => {
564 if _serde::__private::Option::is_some(&m_attachment) {
565 return _serde::__private::Err(
566 <__A::Error as _serde::de::Error>::duplicate_field(
567 "attachment",
568 ),
569 );
570 }
571 m_attachment = _serde::__private::Some(
572 match __A::next_value::<Pointer>(&mut __map) {
573 _serde::__private::Ok(__val) => __val,
574 _serde::__private::Err(__err) => {
575 return _serde::__private::Err(__err);
576 }
577 },
578 );
579 }
580 _ => {}
581 }
582 }
583 let m_sendToAttacherOnAttach = match m_sendToAttacherOnAttach {
584 _serde::__private::Some(__field) => __field,
585 _serde::__private::None => {
586 return _serde::__private::Err(
587 <__A::Error as _serde::de::Error>::missing_field(
588 "sendToAttacherOnAttach",
589 ),
590 );
591 }
592 };
593 let m_sendToAttacheeOnAttach = match m_sendToAttacheeOnAttach {
594 _serde::__private::Some(__field) => __field,
595 _serde::__private::None => {
596 return _serde::__private::Err(
597 <__A::Error as _serde::de::Error>::missing_field(
598 "sendToAttacheeOnAttach",
599 ),
600 );
601 }
602 };
603 let m_sendToAttacherOnDetach = match m_sendToAttacherOnDetach {
604 _serde::__private::Some(__field) => __field,
605 _serde::__private::None => {
606 return _serde::__private::Err(
607 <__A::Error as _serde::de::Error>::missing_field(
608 "sendToAttacherOnDetach",
609 ),
610 );
611 }
612 };
613 let m_sendToAttacheeOnDetach = match m_sendToAttacheeOnDetach {
614 _serde::__private::Some(__field) => __field,
615 _serde::__private::None => {
616 return _serde::__private::Err(
617 <__A::Error as _serde::de::Error>::missing_field(
618 "sendToAttacheeOnDetach",
619 ),
620 );
621 }
622 };
623 let m_attachmentSetup = match m_attachmentSetup {
624 _serde::__private::Some(__field) => __field,
625 _serde::__private::None => {
626 return _serde::__private::Err(
627 <__A::Error as _serde::de::Error>::missing_field(
628 "attachmentSetup",
629 ),
630 );
631 }
632 };
633 let m_attacherHandle = match m_attacherHandle {
634 _serde::__private::Some(__field) => __field,
635 _serde::__private::None => {
636 return _serde::__private::Err(
637 <__A::Error as _serde::de::Error>::missing_field(
638 "attacherHandle",
639 ),
640 );
641 }
642 };
643 let m_attacheeHandle = match m_attacheeHandle {
644 _serde::__private::Some(__field) => __field,
645 _serde::__private::None => {
646 return _serde::__private::Err(
647 <__A::Error as _serde::de::Error>::missing_field(
648 "attacheeHandle",
649 ),
650 );
651 }
652 };
653 let m_attacheeLayer = match m_attacheeLayer {
654 _serde::__private::Some(__field) => __field,
655 _serde::__private::None => {
656 return _serde::__private::Err(
657 <__A::Error as _serde::de::Error>::missing_field(
658 "attacheeLayer",
659 ),
660 );
661 }
662 };
663 let m_attacheeRB = match m_attacheeRB {
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 "attacheeRB",
669 ),
670 );
671 }
672 };
673 let m_oldMotionType = match m_oldMotionType {
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 "oldMotionType",
679 ),
680 );
681 }
682 };
683 let m_oldFilterInfo = match m_oldFilterInfo {
684 _serde::__private::Some(__field) => __field,
685 _serde::__private::None => {
686 return _serde::__private::Err(
687 <__A::Error as _serde::de::Error>::missing_field(
688 "oldFilterInfo",
689 ),
690 );
691 }
692 };
693 let m_attachment = match m_attachment {
694 _serde::__private::Some(__field) => __field,
695 _serde::__private::None => {
696 return _serde::__private::Err(
697 <__A::Error as _serde::de::Error>::missing_field(
698 "attachment",
699 ),
700 );
701 }
702 };
703 _serde::__private::Ok(hkbAttachmentModifier {
704 __ptr,
705 parent,
706 m_sendToAttacherOnAttach,
707 m_sendToAttacheeOnAttach,
708 m_sendToAttacherOnDetach,
709 m_sendToAttacheeOnDetach,
710 m_attachmentSetup,
711 m_attacherHandle,
712 m_attacheeHandle,
713 m_attacheeLayer,
714 m_attacheeRB,
715 m_oldMotionType,
716 m_oldFilterInfo,
717 m_attachment,
718 })
719 }
720 #[allow(clippy::manual_unwrap_or_default)]
721 fn visit_struct<__A>(
722 self,
723 mut __map: __A,
724 ) -> _serde::__private::Result<Self::Value, __A::Error>
725 where
726 __A: _serde::de::MapAccess<'de>,
727 {
728 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
729 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
730 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
731 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
732 let mut m_sendToAttacherOnAttach: _serde::__private::Option<
733 hkbEventProperty,
734 > = _serde::__private::None;
735 let mut m_sendToAttacheeOnAttach: _serde::__private::Option<
736 hkbEventProperty,
737 > = _serde::__private::None;
738 let mut m_sendToAttacherOnDetach: _serde::__private::Option<
739 hkbEventProperty,
740 > = _serde::__private::None;
741 let mut m_sendToAttacheeOnDetach: _serde::__private::Option<
742 hkbEventProperty,
743 > = _serde::__private::None;
744 let mut m_attachmentSetup: _serde::__private::Option<Pointer> = _serde::__private::None;
745 let mut m_attacherHandle: _serde::__private::Option<Pointer> = _serde::__private::None;
746 let mut m_attacheeHandle: _serde::__private::Option<Pointer> = _serde::__private::None;
747 let mut m_attacheeLayer: _serde::__private::Option<i32> = _serde::__private::None;
748 while let _serde::__private::Some(__key) = {
749 __A::next_key::<__Field>(&mut __map)?
750 } {
751 match __key {
752 __Field::m_variableBindingSet => {
753 #[cfg(
754 any(feature = "strict", feature = "ignore_duplicates")
755 )]
756 if _serde::__private::Option::is_some(
757 &m_variableBindingSet,
758 ) {
759 #[cfg(feature = "ignore_duplicates")]
760 {
761 __A::skip_value(&mut __map)?;
762 continue;
763 }
764 #[cfg(feature = "strict")]
765 return _serde::__private::Err(
766 <__A::Error as _serde::de::Error>::duplicate_field(
767 "variableBindingSet",
768 ),
769 );
770 }
771 m_variableBindingSet = _serde::__private::Some(
772 match __A::next_value::<Pointer>(&mut __map) {
773 _serde::__private::Ok(__val) => __val,
774 _serde::__private::Err(__err) => {
775 return _serde::__private::Err(__err);
776 }
777 },
778 );
779 }
780 __Field::m_userData => {
781 #[cfg(
782 any(feature = "strict", feature = "ignore_duplicates")
783 )]
784 if _serde::__private::Option::is_some(&m_userData) {
785 #[cfg(feature = "ignore_duplicates")]
786 {
787 __A::skip_value(&mut __map)?;
788 continue;
789 }
790 #[cfg(feature = "strict")]
791 return _serde::__private::Err(
792 <__A::Error as _serde::de::Error>::duplicate_field(
793 "userData",
794 ),
795 );
796 }
797 m_userData = _serde::__private::Some(
798 match __A::next_value::<Ulong>(&mut __map) {
799 _serde::__private::Ok(__val) => __val,
800 _serde::__private::Err(__err) => {
801 return _serde::__private::Err(__err);
802 }
803 },
804 );
805 }
806 __Field::m_name => {
807 #[cfg(
808 any(feature = "strict", feature = "ignore_duplicates")
809 )]
810 if _serde::__private::Option::is_some(&m_name) {
811 #[cfg(feature = "ignore_duplicates")]
812 {
813 __A::skip_value(&mut __map)?;
814 continue;
815 }
816 #[cfg(feature = "strict")]
817 return _serde::__private::Err(
818 <__A::Error as _serde::de::Error>::duplicate_field("name"),
819 );
820 }
821 m_name = _serde::__private::Some(
822 match __A::next_value::<StringPtr<'de>>(&mut __map) {
823 _serde::__private::Ok(__val) => __val,
824 _serde::__private::Err(__err) => {
825 return _serde::__private::Err(__err);
826 }
827 },
828 );
829 }
830 __Field::m_enable => {
831 #[cfg(
832 any(feature = "strict", feature = "ignore_duplicates")
833 )]
834 if _serde::__private::Option::is_some(&m_enable) {
835 #[cfg(feature = "ignore_duplicates")]
836 {
837 __A::skip_value(&mut __map)?;
838 continue;
839 }
840 #[cfg(feature = "strict")]
841 return _serde::__private::Err(
842 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
843 );
844 }
845 m_enable = _serde::__private::Some(
846 match __A::next_value::<bool>(&mut __map) {
847 _serde::__private::Ok(__val) => __val,
848 _serde::__private::Err(__err) => {
849 return _serde::__private::Err(__err);
850 }
851 },
852 );
853 }
854 __Field::m_sendToAttacherOnAttach => {
855 #[cfg(
856 any(feature = "strict", feature = "ignore_duplicates")
857 )]
858 if _serde::__private::Option::is_some(
859 &m_sendToAttacherOnAttach,
860 ) {
861 #[cfg(feature = "ignore_duplicates")]
862 {
863 __A::skip_value(&mut __map)?;
864 continue;
865 }
866 #[cfg(feature = "strict")]
867 return _serde::__private::Err(
868 <__A::Error as _serde::de::Error>::duplicate_field(
869 "sendToAttacherOnAttach",
870 ),
871 );
872 }
873 m_sendToAttacherOnAttach = _serde::__private::Some(
874 match __A::next_value::<hkbEventProperty>(&mut __map) {
875 _serde::__private::Ok(__val) => __val,
876 _serde::__private::Err(__err) => {
877 return _serde::__private::Err(__err);
878 }
879 },
880 );
881 }
882 __Field::m_sendToAttacheeOnAttach => {
883 #[cfg(
884 any(feature = "strict", feature = "ignore_duplicates")
885 )]
886 if _serde::__private::Option::is_some(
887 &m_sendToAttacheeOnAttach,
888 ) {
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 "sendToAttacheeOnAttach",
898 ),
899 );
900 }
901 m_sendToAttacheeOnAttach = _serde::__private::Some(
902 match __A::next_value::<hkbEventProperty>(&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_sendToAttacherOnDetach => {
911 #[cfg(
912 any(feature = "strict", feature = "ignore_duplicates")
913 )]
914 if _serde::__private::Option::is_some(
915 &m_sendToAttacherOnDetach,
916 ) {
917 #[cfg(feature = "ignore_duplicates")]
918 {
919 __A::skip_value(&mut __map)?;
920 continue;
921 }
922 #[cfg(feature = "strict")]
923 return _serde::__private::Err(
924 <__A::Error as _serde::de::Error>::duplicate_field(
925 "sendToAttacherOnDetach",
926 ),
927 );
928 }
929 m_sendToAttacherOnDetach = _serde::__private::Some(
930 match __A::next_value::<hkbEventProperty>(&mut __map) {
931 _serde::__private::Ok(__val) => __val,
932 _serde::__private::Err(__err) => {
933 return _serde::__private::Err(__err);
934 }
935 },
936 );
937 }
938 __Field::m_sendToAttacheeOnDetach => {
939 #[cfg(
940 any(feature = "strict", feature = "ignore_duplicates")
941 )]
942 if _serde::__private::Option::is_some(
943 &m_sendToAttacheeOnDetach,
944 ) {
945 #[cfg(feature = "ignore_duplicates")]
946 {
947 __A::skip_value(&mut __map)?;
948 continue;
949 }
950 #[cfg(feature = "strict")]
951 return _serde::__private::Err(
952 <__A::Error as _serde::de::Error>::duplicate_field(
953 "sendToAttacheeOnDetach",
954 ),
955 );
956 }
957 m_sendToAttacheeOnDetach = _serde::__private::Some(
958 match __A::next_value::<hkbEventProperty>(&mut __map) {
959 _serde::__private::Ok(__val) => __val,
960 _serde::__private::Err(__err) => {
961 return _serde::__private::Err(__err);
962 }
963 },
964 );
965 }
966 __Field::m_attachmentSetup => {
967 #[cfg(
968 any(feature = "strict", feature = "ignore_duplicates")
969 )]
970 if _serde::__private::Option::is_some(&m_attachmentSetup) {
971 #[cfg(feature = "ignore_duplicates")]
972 {
973 __A::skip_value(&mut __map)?;
974 continue;
975 }
976 #[cfg(feature = "strict")]
977 return _serde::__private::Err(
978 <__A::Error as _serde::de::Error>::duplicate_field(
979 "attachmentSetup",
980 ),
981 );
982 }
983 m_attachmentSetup = _serde::__private::Some(
984 match __A::next_value::<Pointer>(&mut __map) {
985 _serde::__private::Ok(__val) => __val,
986 _serde::__private::Err(__err) => {
987 return _serde::__private::Err(__err);
988 }
989 },
990 );
991 }
992 __Field::m_attacherHandle => {
993 #[cfg(
994 any(feature = "strict", feature = "ignore_duplicates")
995 )]
996 if _serde::__private::Option::is_some(&m_attacherHandle) {
997 #[cfg(feature = "ignore_duplicates")]
998 {
999 __A::skip_value(&mut __map)?;
1000 continue;
1001 }
1002 #[cfg(feature = "strict")]
1003 return _serde::__private::Err(
1004 <__A::Error as _serde::de::Error>::duplicate_field(
1005 "attacherHandle",
1006 ),
1007 );
1008 }
1009 m_attacherHandle = _serde::__private::Some(
1010 match __A::next_value::<Pointer>(&mut __map) {
1011 _serde::__private::Ok(__val) => __val,
1012 _serde::__private::Err(__err) => {
1013 return _serde::__private::Err(__err);
1014 }
1015 },
1016 );
1017 }
1018 __Field::m_attacheeHandle => {
1019 #[cfg(
1020 any(feature = "strict", feature = "ignore_duplicates")
1021 )]
1022 if _serde::__private::Option::is_some(&m_attacheeHandle) {
1023 #[cfg(feature = "ignore_duplicates")]
1024 {
1025 __A::skip_value(&mut __map)?;
1026 continue;
1027 }
1028 #[cfg(feature = "strict")]
1029 return _serde::__private::Err(
1030 <__A::Error as _serde::de::Error>::duplicate_field(
1031 "attacheeHandle",
1032 ),
1033 );
1034 }
1035 m_attacheeHandle = _serde::__private::Some(
1036 match __A::next_value::<Pointer>(&mut __map) {
1037 _serde::__private::Ok(__val) => __val,
1038 _serde::__private::Err(__err) => {
1039 return _serde::__private::Err(__err);
1040 }
1041 },
1042 );
1043 }
1044 __Field::m_attacheeLayer => {
1045 #[cfg(
1046 any(feature = "strict", feature = "ignore_duplicates")
1047 )]
1048 if _serde::__private::Option::is_some(&m_attacheeLayer) {
1049 #[cfg(feature = "ignore_duplicates")]
1050 {
1051 __A::skip_value(&mut __map)?;
1052 continue;
1053 }
1054 #[cfg(feature = "strict")]
1055 return _serde::__private::Err(
1056 <__A::Error as _serde::de::Error>::duplicate_field(
1057 "attacheeLayer",
1058 ),
1059 );
1060 }
1061 m_attacheeLayer = _serde::__private::Some(
1062 match __A::next_value::<i32>(&mut __map) {
1063 _serde::__private::Ok(__val) => __val,
1064 _serde::__private::Err(__err) => {
1065 return _serde::__private::Err(__err);
1066 }
1067 },
1068 );
1069 }
1070 _ => __A::skip_value(&mut __map)?,
1071 }
1072 }
1073 let m_variableBindingSet = match m_variableBindingSet {
1074 _serde::__private::Some(__field) => __field,
1075 _serde::__private::None => {
1076 #[cfg(feature = "strict")]
1077 return _serde::__private::Err(
1078 <__A::Error as _serde::de::Error>::missing_field(
1079 "variableBindingSet",
1080 ),
1081 );
1082 #[cfg(not(feature = "strict"))] Default::default()
1083 }
1084 };
1085 let m_userData = match m_userData {
1086 _serde::__private::Some(__field) => __field,
1087 _serde::__private::None => {
1088 #[cfg(feature = "strict")]
1089 return _serde::__private::Err(
1090 <__A::Error as _serde::de::Error>::missing_field("userData"),
1091 );
1092 #[cfg(not(feature = "strict"))] Default::default()
1093 }
1094 };
1095 let m_name = match m_name {
1096 _serde::__private::Some(__field) => __field,
1097 _serde::__private::None => {
1098 #[cfg(feature = "strict")]
1099 return _serde::__private::Err(
1100 <__A::Error as _serde::de::Error>::missing_field("name"),
1101 );
1102 #[cfg(not(feature = "strict"))] Default::default()
1103 }
1104 };
1105 let m_enable = match m_enable {
1106 _serde::__private::Some(__field) => __field,
1107 _serde::__private::None => {
1108 #[cfg(feature = "strict")]
1109 return _serde::__private::Err(
1110 <__A::Error as _serde::de::Error>::missing_field("enable"),
1111 );
1112 #[cfg(not(feature = "strict"))] Default::default()
1113 }
1114 };
1115 let m_sendToAttacherOnAttach = match m_sendToAttacherOnAttach {
1116 _serde::__private::Some(__field) => __field,
1117 _serde::__private::None => {
1118 #[cfg(feature = "strict")]
1119 return _serde::__private::Err(
1120 <__A::Error as _serde::de::Error>::missing_field(
1121 "sendToAttacherOnAttach",
1122 ),
1123 );
1124 #[cfg(not(feature = "strict"))] Default::default()
1125 }
1126 };
1127 let m_sendToAttacheeOnAttach = match m_sendToAttacheeOnAttach {
1128 _serde::__private::Some(__field) => __field,
1129 _serde::__private::None => {
1130 #[cfg(feature = "strict")]
1131 return _serde::__private::Err(
1132 <__A::Error as _serde::de::Error>::missing_field(
1133 "sendToAttacheeOnAttach",
1134 ),
1135 );
1136 #[cfg(not(feature = "strict"))] Default::default()
1137 }
1138 };
1139 let m_sendToAttacherOnDetach = match m_sendToAttacherOnDetach {
1140 _serde::__private::Some(__field) => __field,
1141 _serde::__private::None => {
1142 #[cfg(feature = "strict")]
1143 return _serde::__private::Err(
1144 <__A::Error as _serde::de::Error>::missing_field(
1145 "sendToAttacherOnDetach",
1146 ),
1147 );
1148 #[cfg(not(feature = "strict"))] Default::default()
1149 }
1150 };
1151 let m_sendToAttacheeOnDetach = match m_sendToAttacheeOnDetach {
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(
1157 "sendToAttacheeOnDetach",
1158 ),
1159 );
1160 #[cfg(not(feature = "strict"))] Default::default()
1161 }
1162 };
1163 let m_attachmentSetup = match m_attachmentSetup {
1164 _serde::__private::Some(__field) => __field,
1165 _serde::__private::None => {
1166 #[cfg(feature = "strict")]
1167 return _serde::__private::Err(
1168 <__A::Error as _serde::de::Error>::missing_field(
1169 "attachmentSetup",
1170 ),
1171 );
1172 #[cfg(not(feature = "strict"))] Default::default()
1173 }
1174 };
1175 let m_attacherHandle = match m_attacherHandle {
1176 _serde::__private::Some(__field) => __field,
1177 _serde::__private::None => {
1178 #[cfg(feature = "strict")]
1179 return _serde::__private::Err(
1180 <__A::Error as _serde::de::Error>::missing_field(
1181 "attacherHandle",
1182 ),
1183 );
1184 #[cfg(not(feature = "strict"))] Default::default()
1185 }
1186 };
1187 let m_attacheeHandle = match m_attacheeHandle {
1188 _serde::__private::Some(__field) => __field,
1189 _serde::__private::None => {
1190 #[cfg(feature = "strict")]
1191 return _serde::__private::Err(
1192 <__A::Error as _serde::de::Error>::missing_field(
1193 "attacheeHandle",
1194 ),
1195 );
1196 #[cfg(not(feature = "strict"))] Default::default()
1197 }
1198 };
1199 let m_attacheeLayer = match m_attacheeLayer {
1200 _serde::__private::Some(__field) => __field,
1201 _serde::__private::None => {
1202 #[cfg(feature = "strict")]
1203 return _serde::__private::Err(
1204 <__A::Error as _serde::de::Error>::missing_field(
1205 "attacheeLayer",
1206 ),
1207 );
1208 #[cfg(not(feature = "strict"))] Default::default()
1209 }
1210 };
1211 let __ptr = None;
1212 let parent = hkBaseObject { __ptr };
1213 let parent = hkReferencedObject {
1214 __ptr,
1215 parent,
1216 ..Default::default()
1217 };
1218 let parent = hkbBindable {
1219 __ptr,
1220 parent,
1221 m_variableBindingSet,
1222 ..Default::default()
1223 };
1224 let parent = hkbNode {
1225 __ptr,
1226 parent,
1227 m_userData,
1228 m_name,
1229 ..Default::default()
1230 };
1231 let parent = hkbModifier {
1232 __ptr,
1233 parent,
1234 m_enable,
1235 ..Default::default()
1236 };
1237 let __ptr = __A::class_ptr(&mut __map);
1238 _serde::__private::Ok(hkbAttachmentModifier {
1239 __ptr,
1240 parent,
1241 m_sendToAttacherOnAttach,
1242 m_sendToAttacheeOnAttach,
1243 m_sendToAttacherOnDetach,
1244 m_sendToAttacheeOnDetach,
1245 m_attachmentSetup,
1246 m_attacherHandle,
1247 m_attacheeHandle,
1248 m_attacheeLayer,
1249 ..Default::default()
1250 })
1251 }
1252 }
1253 const FIELDS: &[&str] = &[
1254 "sendToAttacherOnAttach",
1255 "sendToAttacheeOnAttach",
1256 "sendToAttacherOnDetach",
1257 "sendToAttacheeOnDetach",
1258 "attachmentSetup",
1259 "attacherHandle",
1260 "attacheeHandle",
1261 "attacheeLayer",
1262 "attacheeRB",
1263 "oldMotionType",
1264 "oldFilterInfo",
1265 "attachment",
1266 ];
1267 _serde::Deserializer::deserialize_struct(
1268 deserializer,
1269 "hkbAttachmentModifier",
1270 FIELDS,
1271 __hkbAttachmentModifierVisitor {
1272 marker: _serde::__private::PhantomData::<hkbAttachmentModifier>,
1273 lifetime: _serde::__private::PhantomData,
1274 },
1275 )
1276 }
1277 }
1278};