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