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