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 hkbTransformVectorModifier<'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 = "rotation"))]
36 #[cfg_attr(feature = "serde", serde(rename = "rotation"))]
37 pub m_rotation: Quaternion,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "translation"))]
43 #[cfg_attr(feature = "serde", serde(rename = "translation"))]
44 pub m_translation: Vector4,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "vectorIn"))]
50 #[cfg_attr(feature = "serde", serde(rename = "vectorIn"))]
51 pub m_vectorIn: Vector4,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "vectorOut"))]
57 #[cfg_attr(feature = "serde", serde(rename = "vectorOut"))]
58 pub m_vectorOut: Vector4,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "rotateOnly"))]
64 #[cfg_attr(feature = "serde", serde(rename = "rotateOnly"))]
65 pub m_rotateOnly: bool,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "inverse"))]
71 #[cfg_attr(feature = "serde", serde(rename = "inverse"))]
72 pub m_inverse: bool,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "computeOnActivate"))]
78 #[cfg_attr(feature = "serde", serde(rename = "computeOnActivate"))]
79 pub m_computeOnActivate: bool,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "computeOnModify"))]
85 #[cfg_attr(feature = "serde", serde(rename = "computeOnModify"))]
86 pub m_computeOnModify: bool,
87}
88const _: () = {
89 use havok_serde as _serde;
90 impl<'a> _serde::HavokClass for hkbTransformVectorModifier<'a> {
91 #[inline]
92 fn name(&self) -> &'static str {
93 "hkbTransformVectorModifier"
94 }
95 #[inline]
96 fn signature(&self) -> _serde::__private::Signature {
97 _serde::__private::Signature::new(0xf93e0e24)
98 }
99 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
100 fn deps_indexes(&self) -> Vec<usize> {
101 let mut v = Vec::new();
102 v.push(self.parent.parent.parent.m_variableBindingSet.get());
103 v
104 }
105 }
106 impl<'a> _serde::Serialize for hkbTransformVectorModifier<'a> {
107 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
108 where
109 S: _serde::ser::Serializer,
110 {
111 let class_meta = self
112 .__ptr
113 .map(|name| (name, _serde::__private::Signature::new(0xf93e0e24)));
114 let mut serializer = __serializer
115 .serialize_struct(
116 "hkbTransformVectorModifier",
117 class_meta,
118 (128u64, 160u64),
119 )?;
120 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
121 serializer
122 .skip_field(
123 "memSizeAndFlags",
124 &self.parent.parent.parent.parent.m_memSizeAndFlags,
125 )?;
126 serializer
127 .skip_field(
128 "referenceCount",
129 &self.parent.parent.parent.parent.m_referenceCount,
130 )?;
131 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
132 serializer
133 .serialize_field(
134 "variableBindingSet",
135 &self.parent.parent.parent.m_variableBindingSet,
136 )?;
137 serializer
138 .skip_array_field(
139 "cachedBindables",
140 &self.parent.parent.parent.m_cachedBindables,
141 TypeSize::NonPtr,
142 )?;
143 serializer
144 .skip_field(
145 "areBindablesCached",
146 &self.parent.parent.parent.m_areBindablesCached,
147 )?;
148 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
149 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
150 serializer.serialize_field("name", &self.parent.parent.m_name)?;
151 serializer.skip_field("id", &self.parent.parent.m_id)?;
152 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
153 serializer
154 .skip_fixed_array_field(
155 "padNode",
156 self.parent.parent.m_padNode.as_slice(),
157 TypeSize::NonPtr,
158 )?;
159 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
160 serializer.serialize_field("enable", &self.parent.m_enable)?;
161 serializer
162 .skip_fixed_array_field(
163 "padModifier",
164 self.parent.m_padModifier.as_slice(),
165 TypeSize::NonPtr,
166 )?;
167 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
168 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
169 serializer.serialize_field("rotation", &self.m_rotation)?;
170 serializer.serialize_field("translation", &self.m_translation)?;
171 serializer.serialize_field("vectorIn", &self.m_vectorIn)?;
172 serializer.serialize_field("vectorOut", &self.m_vectorOut)?;
173 serializer.serialize_field("rotateOnly", &self.m_rotateOnly)?;
174 serializer.serialize_field("inverse", &self.m_inverse)?;
175 serializer.serialize_field("computeOnActivate", &self.m_computeOnActivate)?;
176 serializer.serialize_field("computeOnModify", &self.m_computeOnModify)?;
177 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 12usize].as_slice())?;
178 serializer.end()
179 }
180 }
181};
182#[doc(hidden)]
183#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
184const _: () = {
185 use havok_serde as _serde;
186 #[automatically_derived]
187 impl<'de> _serde::Deserialize<'de> for hkbTransformVectorModifier<'de> {
188 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
189 where
190 __D: _serde::Deserializer<'de>,
191 {
192 #[allow(non_camel_case_types)]
193 enum __Field {
194 m_variableBindingSet,
195 m_userData,
196 m_name,
197 m_enable,
198 m_rotation,
199 m_translation,
200 m_vectorIn,
201 m_vectorOut,
202 m_rotateOnly,
203 m_inverse,
204 m_computeOnActivate,
205 m_computeOnModify,
206 __ignore,
207 }
208 struct __FieldVisitor;
209 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
210 type Value = __Field;
211 fn expecting(
212 &self,
213 __formatter: &mut core::fmt::Formatter,
214 ) -> core::fmt::Result {
215 core::fmt::Formatter::write_str(__formatter, "field identifier")
216 }
217 #[allow(clippy::match_single_binding)]
219 #[allow(clippy::reversed_empty_ranges)]
220 #[allow(clippy::single_match)]
221 fn visit_key<__E>(
222 self,
223 __value: &str,
224 ) -> core::result::Result<Self::Value, __E>
225 where
226 __E: _serde::de::Error,
227 {
228 match __value {
229 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
230 "userData" => Ok(__Field::m_userData),
231 "name" => Ok(__Field::m_name),
232 "enable" => Ok(__Field::m_enable),
233 "rotation" => Ok(__Field::m_rotation),
234 "translation" => Ok(__Field::m_translation),
235 "vectorIn" => Ok(__Field::m_vectorIn),
236 "vectorOut" => Ok(__Field::m_vectorOut),
237 "rotateOnly" => Ok(__Field::m_rotateOnly),
238 "inverse" => Ok(__Field::m_inverse),
239 "computeOnActivate" => Ok(__Field::m_computeOnActivate),
240 "computeOnModify" => Ok(__Field::m_computeOnModify),
241 _ => Ok(__Field::__ignore),
242 }
243 }
244 }
245 impl<'de> _serde::Deserialize<'de> for __Field {
246 #[inline]
247 fn deserialize<__D>(
248 __deserializer: __D,
249 ) -> core::result::Result<Self, __D::Error>
250 where
251 __D: _serde::Deserializer<'de>,
252 {
253 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
254 }
255 }
256 struct __hkbTransformVectorModifierVisitor<'de> {
257 marker: _serde::__private::PhantomData<hkbTransformVectorModifier<'de>>,
258 lifetime: _serde::__private::PhantomData<&'de ()>,
259 }
260 #[allow(clippy::match_single_binding)]
261 #[allow(clippy::reversed_empty_ranges)]
262 #[allow(clippy::single_match)]
263 impl<'de> _serde::de::Visitor<'de>
264 for __hkbTransformVectorModifierVisitor<'de> {
265 type Value = hkbTransformVectorModifier<'de>;
266 fn expecting(
267 &self,
268 __formatter: &mut core::fmt::Formatter,
269 ) -> core::fmt::Result {
270 core::fmt::Formatter::write_str(
271 __formatter,
272 "struct hkbTransformVectorModifier",
273 )
274 }
275 fn visit_struct_for_bytes<__A>(
276 self,
277 mut __map: __A,
278 ) -> _serde::__private::Result<Self::Value, __A::Error>
279 where
280 __A: _serde::de::MapAccess<'de>,
281 {
282 let __ptr = __A::class_ptr(&mut __map);
283 let parent = __A::parent_value(&mut __map)?;
284 let mut m_rotation: _serde::__private::Option<Quaternion> = _serde::__private::None;
285 let mut m_translation: _serde::__private::Option<Vector4> = _serde::__private::None;
286 let mut m_vectorIn: _serde::__private::Option<Vector4> = _serde::__private::None;
287 let mut m_vectorOut: _serde::__private::Option<Vector4> = _serde::__private::None;
288 let mut m_rotateOnly: _serde::__private::Option<bool> = _serde::__private::None;
289 let mut m_inverse: _serde::__private::Option<bool> = _serde::__private::None;
290 let mut m_computeOnActivate: _serde::__private::Option<bool> = _serde::__private::None;
291 let mut m_computeOnModify: _serde::__private::Option<bool> = _serde::__private::None;
292 for i in 0..8usize {
293 match i {
294 0usize => {
295 if _serde::__private::Option::is_some(&m_rotation) {
296 return _serde::__private::Err(
297 <__A::Error as _serde::de::Error>::duplicate_field(
298 "rotation",
299 ),
300 );
301 }
302 __A::pad(&mut __map, 4usize, 0usize)?;
303 m_rotation = _serde::__private::Some(
304 match __A::next_value::<Quaternion>(&mut __map) {
305 _serde::__private::Ok(__val) => __val,
306 _serde::__private::Err(__err) => {
307 return _serde::__private::Err(__err);
308 }
309 },
310 );
311 }
312 1usize => {
313 if _serde::__private::Option::is_some(&m_translation) {
314 return _serde::__private::Err(
315 <__A::Error as _serde::de::Error>::duplicate_field(
316 "translation",
317 ),
318 );
319 }
320 m_translation = _serde::__private::Some(
321 match __A::next_value::<Vector4>(&mut __map) {
322 _serde::__private::Ok(__val) => __val,
323 _serde::__private::Err(__err) => {
324 return _serde::__private::Err(__err);
325 }
326 },
327 );
328 }
329 2usize => {
330 if _serde::__private::Option::is_some(&m_vectorIn) {
331 return _serde::__private::Err(
332 <__A::Error as _serde::de::Error>::duplicate_field(
333 "vectorIn",
334 ),
335 );
336 }
337 m_vectorIn = _serde::__private::Some(
338 match __A::next_value::<Vector4>(&mut __map) {
339 _serde::__private::Ok(__val) => __val,
340 _serde::__private::Err(__err) => {
341 return _serde::__private::Err(__err);
342 }
343 },
344 );
345 }
346 3usize => {
347 if _serde::__private::Option::is_some(&m_vectorOut) {
348 return _serde::__private::Err(
349 <__A::Error as _serde::de::Error>::duplicate_field(
350 "vectorOut",
351 ),
352 );
353 }
354 m_vectorOut = _serde::__private::Some(
355 match __A::next_value::<Vector4>(&mut __map) {
356 _serde::__private::Ok(__val) => __val,
357 _serde::__private::Err(__err) => {
358 return _serde::__private::Err(__err);
359 }
360 },
361 );
362 }
363 4usize => {
364 if _serde::__private::Option::is_some(&m_rotateOnly) {
365 return _serde::__private::Err(
366 <__A::Error as _serde::de::Error>::duplicate_field(
367 "rotateOnly",
368 ),
369 );
370 }
371 m_rotateOnly = _serde::__private::Some(
372 match __A::next_value::<bool>(&mut __map) {
373 _serde::__private::Ok(__val) => __val,
374 _serde::__private::Err(__err) => {
375 return _serde::__private::Err(__err);
376 }
377 },
378 );
379 }
380 5usize => {
381 if _serde::__private::Option::is_some(&m_inverse) {
382 return _serde::__private::Err(
383 <__A::Error as _serde::de::Error>::duplicate_field(
384 "inverse",
385 ),
386 );
387 }
388 m_inverse = _serde::__private::Some(
389 match __A::next_value::<bool>(&mut __map) {
390 _serde::__private::Ok(__val) => __val,
391 _serde::__private::Err(__err) => {
392 return _serde::__private::Err(__err);
393 }
394 },
395 );
396 }
397 6usize => {
398 if _serde::__private::Option::is_some(
399 &m_computeOnActivate,
400 ) {
401 return _serde::__private::Err(
402 <__A::Error as _serde::de::Error>::duplicate_field(
403 "computeOnActivate",
404 ),
405 );
406 }
407 m_computeOnActivate = _serde::__private::Some(
408 match __A::next_value::<bool>(&mut __map) {
409 _serde::__private::Ok(__val) => __val,
410 _serde::__private::Err(__err) => {
411 return _serde::__private::Err(__err);
412 }
413 },
414 );
415 }
416 7usize => {
417 if _serde::__private::Option::is_some(&m_computeOnModify) {
418 return _serde::__private::Err(
419 <__A::Error as _serde::de::Error>::duplicate_field(
420 "computeOnModify",
421 ),
422 );
423 }
424 m_computeOnModify = _serde::__private::Some(
425 match __A::next_value::<bool>(&mut __map) {
426 _serde::__private::Ok(__val) => __val,
427 _serde::__private::Err(__err) => {
428 return _serde::__private::Err(__err);
429 }
430 },
431 );
432 }
433 _ => {}
434 }
435 }
436 __A::pad(&mut __map, 12usize, 12usize)?;
437 let m_rotation = match m_rotation {
438 _serde::__private::Some(__field) => __field,
439 _serde::__private::None => {
440 return _serde::__private::Err(
441 <__A::Error as _serde::de::Error>::missing_field("rotation"),
442 );
443 }
444 };
445 let m_translation = match m_translation {
446 _serde::__private::Some(__field) => __field,
447 _serde::__private::None => {
448 return _serde::__private::Err(
449 <__A::Error as _serde::de::Error>::missing_field(
450 "translation",
451 ),
452 );
453 }
454 };
455 let m_vectorIn = match m_vectorIn {
456 _serde::__private::Some(__field) => __field,
457 _serde::__private::None => {
458 return _serde::__private::Err(
459 <__A::Error as _serde::de::Error>::missing_field("vectorIn"),
460 );
461 }
462 };
463 let m_vectorOut = match m_vectorOut {
464 _serde::__private::Some(__field) => __field,
465 _serde::__private::None => {
466 return _serde::__private::Err(
467 <__A::Error as _serde::de::Error>::missing_field(
468 "vectorOut",
469 ),
470 );
471 }
472 };
473 let m_rotateOnly = match m_rotateOnly {
474 _serde::__private::Some(__field) => __field,
475 _serde::__private::None => {
476 return _serde::__private::Err(
477 <__A::Error as _serde::de::Error>::missing_field(
478 "rotateOnly",
479 ),
480 );
481 }
482 };
483 let m_inverse = match m_inverse {
484 _serde::__private::Some(__field) => __field,
485 _serde::__private::None => {
486 return _serde::__private::Err(
487 <__A::Error as _serde::de::Error>::missing_field("inverse"),
488 );
489 }
490 };
491 let m_computeOnActivate = match m_computeOnActivate {
492 _serde::__private::Some(__field) => __field,
493 _serde::__private::None => {
494 return _serde::__private::Err(
495 <__A::Error as _serde::de::Error>::missing_field(
496 "computeOnActivate",
497 ),
498 );
499 }
500 };
501 let m_computeOnModify = match m_computeOnModify {
502 _serde::__private::Some(__field) => __field,
503 _serde::__private::None => {
504 return _serde::__private::Err(
505 <__A::Error as _serde::de::Error>::missing_field(
506 "computeOnModify",
507 ),
508 );
509 }
510 };
511 _serde::__private::Ok(hkbTransformVectorModifier {
512 __ptr,
513 parent,
514 m_rotation,
515 m_translation,
516 m_vectorIn,
517 m_vectorOut,
518 m_rotateOnly,
519 m_inverse,
520 m_computeOnActivate,
521 m_computeOnModify,
522 })
523 }
524 #[allow(clippy::manual_unwrap_or_default)]
525 fn visit_struct<__A>(
526 self,
527 mut __map: __A,
528 ) -> _serde::__private::Result<Self::Value, __A::Error>
529 where
530 __A: _serde::de::MapAccess<'de>,
531 {
532 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
533 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
534 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
535 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
536 let mut m_rotation: _serde::__private::Option<Quaternion> = _serde::__private::None;
537 let mut m_translation: _serde::__private::Option<Vector4> = _serde::__private::None;
538 let mut m_vectorIn: _serde::__private::Option<Vector4> = _serde::__private::None;
539 let mut m_vectorOut: _serde::__private::Option<Vector4> = _serde::__private::None;
540 let mut m_rotateOnly: _serde::__private::Option<bool> = _serde::__private::None;
541 let mut m_inverse: _serde::__private::Option<bool> = _serde::__private::None;
542 let mut m_computeOnActivate: _serde::__private::Option<bool> = _serde::__private::None;
543 let mut m_computeOnModify: _serde::__private::Option<bool> = _serde::__private::None;
544 while let _serde::__private::Some(__key) = {
545 __A::next_key::<__Field>(&mut __map)?
546 } {
547 match __key {
548 __Field::m_variableBindingSet => {
549 #[cfg(
550 any(feature = "strict", feature = "ignore_duplicates")
551 )]
552 if _serde::__private::Option::is_some(
553 &m_variableBindingSet,
554 ) {
555 #[cfg(feature = "ignore_duplicates")]
556 {
557 __A::skip_value(&mut __map)?;
558 continue;
559 }
560 #[cfg(feature = "strict")]
561 return _serde::__private::Err(
562 <__A::Error as _serde::de::Error>::duplicate_field(
563 "variableBindingSet",
564 ),
565 );
566 }
567 m_variableBindingSet = _serde::__private::Some(
568 match __A::next_value::<Pointer>(&mut __map) {
569 _serde::__private::Ok(__val) => __val,
570 _serde::__private::Err(__err) => {
571 return _serde::__private::Err(__err);
572 }
573 },
574 );
575 }
576 __Field::m_userData => {
577 #[cfg(
578 any(feature = "strict", feature = "ignore_duplicates")
579 )]
580 if _serde::__private::Option::is_some(&m_userData) {
581 #[cfg(feature = "ignore_duplicates")]
582 {
583 __A::skip_value(&mut __map)?;
584 continue;
585 }
586 #[cfg(feature = "strict")]
587 return _serde::__private::Err(
588 <__A::Error as _serde::de::Error>::duplicate_field(
589 "userData",
590 ),
591 );
592 }
593 m_userData = _serde::__private::Some(
594 match __A::next_value::<Ulong>(&mut __map) {
595 _serde::__private::Ok(__val) => __val,
596 _serde::__private::Err(__err) => {
597 return _serde::__private::Err(__err);
598 }
599 },
600 );
601 }
602 __Field::m_name => {
603 #[cfg(
604 any(feature = "strict", feature = "ignore_duplicates")
605 )]
606 if _serde::__private::Option::is_some(&m_name) {
607 #[cfg(feature = "ignore_duplicates")]
608 {
609 __A::skip_value(&mut __map)?;
610 continue;
611 }
612 #[cfg(feature = "strict")]
613 return _serde::__private::Err(
614 <__A::Error as _serde::de::Error>::duplicate_field("name"),
615 );
616 }
617 m_name = _serde::__private::Some(
618 match __A::next_value::<StringPtr<'de>>(&mut __map) {
619 _serde::__private::Ok(__val) => __val,
620 _serde::__private::Err(__err) => {
621 return _serde::__private::Err(__err);
622 }
623 },
624 );
625 }
626 __Field::m_enable => {
627 #[cfg(
628 any(feature = "strict", feature = "ignore_duplicates")
629 )]
630 if _serde::__private::Option::is_some(&m_enable) {
631 #[cfg(feature = "ignore_duplicates")]
632 {
633 __A::skip_value(&mut __map)?;
634 continue;
635 }
636 #[cfg(feature = "strict")]
637 return _serde::__private::Err(
638 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
639 );
640 }
641 m_enable = _serde::__private::Some(
642 match __A::next_value::<bool>(&mut __map) {
643 _serde::__private::Ok(__val) => __val,
644 _serde::__private::Err(__err) => {
645 return _serde::__private::Err(__err);
646 }
647 },
648 );
649 }
650 __Field::m_rotation => {
651 #[cfg(
652 any(feature = "strict", feature = "ignore_duplicates")
653 )]
654 if _serde::__private::Option::is_some(&m_rotation) {
655 #[cfg(feature = "ignore_duplicates")]
656 {
657 __A::skip_value(&mut __map)?;
658 continue;
659 }
660 #[cfg(feature = "strict")]
661 return _serde::__private::Err(
662 <__A::Error as _serde::de::Error>::duplicate_field(
663 "rotation",
664 ),
665 );
666 }
667 m_rotation = _serde::__private::Some(
668 match __A::next_value::<Quaternion>(&mut __map) {
669 _serde::__private::Ok(__val) => __val,
670 _serde::__private::Err(__err) => {
671 return _serde::__private::Err(__err);
672 }
673 },
674 );
675 }
676 __Field::m_translation => {
677 #[cfg(
678 any(feature = "strict", feature = "ignore_duplicates")
679 )]
680 if _serde::__private::Option::is_some(&m_translation) {
681 #[cfg(feature = "ignore_duplicates")]
682 {
683 __A::skip_value(&mut __map)?;
684 continue;
685 }
686 #[cfg(feature = "strict")]
687 return _serde::__private::Err(
688 <__A::Error as _serde::de::Error>::duplicate_field(
689 "translation",
690 ),
691 );
692 }
693 m_translation = _serde::__private::Some(
694 match __A::next_value::<Vector4>(&mut __map) {
695 _serde::__private::Ok(__val) => __val,
696 _serde::__private::Err(__err) => {
697 return _serde::__private::Err(__err);
698 }
699 },
700 );
701 }
702 __Field::m_vectorIn => {
703 #[cfg(
704 any(feature = "strict", feature = "ignore_duplicates")
705 )]
706 if _serde::__private::Option::is_some(&m_vectorIn) {
707 #[cfg(feature = "ignore_duplicates")]
708 {
709 __A::skip_value(&mut __map)?;
710 continue;
711 }
712 #[cfg(feature = "strict")]
713 return _serde::__private::Err(
714 <__A::Error as _serde::de::Error>::duplicate_field(
715 "vectorIn",
716 ),
717 );
718 }
719 m_vectorIn = _serde::__private::Some(
720 match __A::next_value::<Vector4>(&mut __map) {
721 _serde::__private::Ok(__val) => __val,
722 _serde::__private::Err(__err) => {
723 return _serde::__private::Err(__err);
724 }
725 },
726 );
727 }
728 __Field::m_vectorOut => {
729 #[cfg(
730 any(feature = "strict", feature = "ignore_duplicates")
731 )]
732 if _serde::__private::Option::is_some(&m_vectorOut) {
733 #[cfg(feature = "ignore_duplicates")]
734 {
735 __A::skip_value(&mut __map)?;
736 continue;
737 }
738 #[cfg(feature = "strict")]
739 return _serde::__private::Err(
740 <__A::Error as _serde::de::Error>::duplicate_field(
741 "vectorOut",
742 ),
743 );
744 }
745 m_vectorOut = _serde::__private::Some(
746 match __A::next_value::<Vector4>(&mut __map) {
747 _serde::__private::Ok(__val) => __val,
748 _serde::__private::Err(__err) => {
749 return _serde::__private::Err(__err);
750 }
751 },
752 );
753 }
754 __Field::m_rotateOnly => {
755 #[cfg(
756 any(feature = "strict", feature = "ignore_duplicates")
757 )]
758 if _serde::__private::Option::is_some(&m_rotateOnly) {
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 "rotateOnly",
768 ),
769 );
770 }
771 m_rotateOnly = _serde::__private::Some(
772 match __A::next_value::<bool>(&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_inverse => {
781 #[cfg(
782 any(feature = "strict", feature = "ignore_duplicates")
783 )]
784 if _serde::__private::Option::is_some(&m_inverse) {
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 "inverse",
794 ),
795 );
796 }
797 m_inverse = _serde::__private::Some(
798 match __A::next_value::<bool>(&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_computeOnActivate => {
807 #[cfg(
808 any(feature = "strict", feature = "ignore_duplicates")
809 )]
810 if _serde::__private::Option::is_some(
811 &m_computeOnActivate,
812 ) {
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(
821 "computeOnActivate",
822 ),
823 );
824 }
825 m_computeOnActivate = _serde::__private::Some(
826 match __A::next_value::<bool>(&mut __map) {
827 _serde::__private::Ok(__val) => __val,
828 _serde::__private::Err(__err) => {
829 return _serde::__private::Err(__err);
830 }
831 },
832 );
833 }
834 __Field::m_computeOnModify => {
835 #[cfg(
836 any(feature = "strict", feature = "ignore_duplicates")
837 )]
838 if _serde::__private::Option::is_some(&m_computeOnModify) {
839 #[cfg(feature = "ignore_duplicates")]
840 {
841 __A::skip_value(&mut __map)?;
842 continue;
843 }
844 #[cfg(feature = "strict")]
845 return _serde::__private::Err(
846 <__A::Error as _serde::de::Error>::duplicate_field(
847 "computeOnModify",
848 ),
849 );
850 }
851 m_computeOnModify = _serde::__private::Some(
852 match __A::next_value::<bool>(&mut __map) {
853 _serde::__private::Ok(__val) => __val,
854 _serde::__private::Err(__err) => {
855 return _serde::__private::Err(__err);
856 }
857 },
858 );
859 }
860 _ => __A::skip_value(&mut __map)?,
861 }
862 }
863 let m_variableBindingSet = match m_variableBindingSet {
864 _serde::__private::Some(__field) => __field,
865 _serde::__private::None => {
866 #[cfg(feature = "strict")]
867 return _serde::__private::Err(
868 <__A::Error as _serde::de::Error>::missing_field(
869 "variableBindingSet",
870 ),
871 );
872 #[cfg(not(feature = "strict"))] Default::default()
873 }
874 };
875 let m_userData = match m_userData {
876 _serde::__private::Some(__field) => __field,
877 _serde::__private::None => {
878 #[cfg(feature = "strict")]
879 return _serde::__private::Err(
880 <__A::Error as _serde::de::Error>::missing_field("userData"),
881 );
882 #[cfg(not(feature = "strict"))] Default::default()
883 }
884 };
885 let m_name = match m_name {
886 _serde::__private::Some(__field) => __field,
887 _serde::__private::None => {
888 #[cfg(feature = "strict")]
889 return _serde::__private::Err(
890 <__A::Error as _serde::de::Error>::missing_field("name"),
891 );
892 #[cfg(not(feature = "strict"))] Default::default()
893 }
894 };
895 let m_enable = match m_enable {
896 _serde::__private::Some(__field) => __field,
897 _serde::__private::None => {
898 #[cfg(feature = "strict")]
899 return _serde::__private::Err(
900 <__A::Error as _serde::de::Error>::missing_field("enable"),
901 );
902 #[cfg(not(feature = "strict"))] Default::default()
903 }
904 };
905 let m_rotation = match m_rotation {
906 _serde::__private::Some(__field) => __field,
907 _serde::__private::None => {
908 #[cfg(feature = "strict")]
909 return _serde::__private::Err(
910 <__A::Error as _serde::de::Error>::missing_field("rotation"),
911 );
912 #[cfg(not(feature = "strict"))] Default::default()
913 }
914 };
915 let m_translation = match m_translation {
916 _serde::__private::Some(__field) => __field,
917 _serde::__private::None => {
918 #[cfg(feature = "strict")]
919 return _serde::__private::Err(
920 <__A::Error as _serde::de::Error>::missing_field(
921 "translation",
922 ),
923 );
924 #[cfg(not(feature = "strict"))] Default::default()
925 }
926 };
927 let m_vectorIn = match m_vectorIn {
928 _serde::__private::Some(__field) => __field,
929 _serde::__private::None => {
930 #[cfg(feature = "strict")]
931 return _serde::__private::Err(
932 <__A::Error as _serde::de::Error>::missing_field("vectorIn"),
933 );
934 #[cfg(not(feature = "strict"))] Default::default()
935 }
936 };
937 let m_vectorOut = match m_vectorOut {
938 _serde::__private::Some(__field) => __field,
939 _serde::__private::None => {
940 #[cfg(feature = "strict")]
941 return _serde::__private::Err(
942 <__A::Error as _serde::de::Error>::missing_field(
943 "vectorOut",
944 ),
945 );
946 #[cfg(not(feature = "strict"))] Default::default()
947 }
948 };
949 let m_rotateOnly = match m_rotateOnly {
950 _serde::__private::Some(__field) => __field,
951 _serde::__private::None => {
952 #[cfg(feature = "strict")]
953 return _serde::__private::Err(
954 <__A::Error as _serde::de::Error>::missing_field(
955 "rotateOnly",
956 ),
957 );
958 #[cfg(not(feature = "strict"))] Default::default()
959 }
960 };
961 let m_inverse = match m_inverse {
962 _serde::__private::Some(__field) => __field,
963 _serde::__private::None => {
964 #[cfg(feature = "strict")]
965 return _serde::__private::Err(
966 <__A::Error as _serde::de::Error>::missing_field("inverse"),
967 );
968 #[cfg(not(feature = "strict"))] Default::default()
969 }
970 };
971 let m_computeOnActivate = match m_computeOnActivate {
972 _serde::__private::Some(__field) => __field,
973 _serde::__private::None => {
974 #[cfg(feature = "strict")]
975 return _serde::__private::Err(
976 <__A::Error as _serde::de::Error>::missing_field(
977 "computeOnActivate",
978 ),
979 );
980 #[cfg(not(feature = "strict"))] Default::default()
981 }
982 };
983 let m_computeOnModify = match m_computeOnModify {
984 _serde::__private::Some(__field) => __field,
985 _serde::__private::None => {
986 #[cfg(feature = "strict")]
987 return _serde::__private::Err(
988 <__A::Error as _serde::de::Error>::missing_field(
989 "computeOnModify",
990 ),
991 );
992 #[cfg(not(feature = "strict"))] Default::default()
993 }
994 };
995 let __ptr = None;
996 let parent = hkBaseObject { __ptr };
997 let parent = hkReferencedObject {
998 __ptr,
999 parent,
1000 ..Default::default()
1001 };
1002 let parent = hkbBindable {
1003 __ptr,
1004 parent,
1005 m_variableBindingSet,
1006 ..Default::default()
1007 };
1008 let parent = hkbNode {
1009 __ptr,
1010 parent,
1011 m_userData,
1012 m_name,
1013 ..Default::default()
1014 };
1015 let parent = hkbModifier {
1016 __ptr,
1017 parent,
1018 m_enable,
1019 ..Default::default()
1020 };
1021 let __ptr = __A::class_ptr(&mut __map);
1022 _serde::__private::Ok(hkbTransformVectorModifier {
1023 __ptr,
1024 parent,
1025 m_rotation,
1026 m_translation,
1027 m_vectorIn,
1028 m_vectorOut,
1029 m_rotateOnly,
1030 m_inverse,
1031 m_computeOnActivate,
1032 m_computeOnModify,
1033 })
1034 }
1035 }
1036 const FIELDS: &[&str] = &[
1037 "rotation",
1038 "translation",
1039 "vectorIn",
1040 "vectorOut",
1041 "rotateOnly",
1042 "inverse",
1043 "computeOnActivate",
1044 "computeOnModify",
1045 ];
1046 _serde::Deserializer::deserialize_struct(
1047 deserializer,
1048 "hkbTransformVectorModifier",
1049 FIELDS,
1050 __hkbTransformVectorModifierVisitor {
1051 marker: _serde::__private::PhantomData::<hkbTransformVectorModifier>,
1052 lifetime: _serde::__private::PhantomData,
1053 },
1054 )
1055 }
1056 }
1057};