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