havok_classes/generated/
hkxScene_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkxScene`
5/// - version: `1`
6/// - signature: `0x5f673ddd`
7/// - size: `176`(x86)/`224`(x86_64)
8/// -  vtable: `true`
9#[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    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkReferencedObject,
30    /// # C++ Info
31    /// - name: `modeller`(ctype: `hkStringPtr`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: `  4`(x86)/`  8`(x86_64)
34    #[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    /// # C++ Info
39    /// - name: `asset`(ctype: `hkStringPtr`)
40    /// - offset: ` 12`(x86)/` 24`(x86_64)
41    /// - type_size: `  4`(x86)/`  8`(x86_64)
42    #[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    /// # C++ Info
47    /// - name: `sceneLength`(ctype: `hkReal`)
48    /// - offset: ` 16`(x86)/` 32`(x86_64)
49    /// - type_size: `  4`(x86)/`  4`(x86_64)
50    #[cfg_attr(feature = "json_schema", schemars(rename = "sceneLength"))]
51    #[cfg_attr(feature = "serde", serde(rename = "sceneLength"))]
52    pub m_sceneLength: f32,
53    /// # C++ Info
54    /// - name: `rootNode`(ctype: `struct hkxNode*`)
55    /// - offset: ` 20`(x86)/` 40`(x86_64)
56    /// - type_size: `  4`(x86)/`  8`(x86_64)
57    #[cfg_attr(feature = "json_schema", schemars(rename = "rootNode"))]
58    #[cfg_attr(feature = "serde", serde(rename = "rootNode"))]
59    pub m_rootNode: Pointer,
60    /// # C++ Info
61    /// - name: `selectionSets`(ctype: `hkArray<hkxNodeSelectionSet*>`)
62    /// - offset: ` 24`(x86)/` 48`(x86_64)
63    /// - type_size: ` 12`(x86)/` 16`(x86_64)
64    #[cfg_attr(feature = "json_schema", schemars(rename = "selectionSets"))]
65    #[cfg_attr(feature = "serde", serde(rename = "selectionSets"))]
66    pub m_selectionSets: Vec<Pointer>,
67    /// # C++ Info
68    /// - name: `cameras`(ctype: `hkArray<hkxCamera*>`)
69    /// - offset: ` 36`(x86)/` 64`(x86_64)
70    /// - type_size: ` 12`(x86)/` 16`(x86_64)
71    #[cfg_attr(feature = "json_schema", schemars(rename = "cameras"))]
72    #[cfg_attr(feature = "serde", serde(rename = "cameras"))]
73    pub m_cameras: Vec<Pointer>,
74    /// # C++ Info
75    /// - name: `lights`(ctype: `hkArray<hkxLight*>`)
76    /// - offset: ` 48`(x86)/` 80`(x86_64)
77    /// - type_size: ` 12`(x86)/` 16`(x86_64)
78    #[cfg_attr(feature = "json_schema", schemars(rename = "lights"))]
79    #[cfg_attr(feature = "serde", serde(rename = "lights"))]
80    pub m_lights: Vec<Pointer>,
81    /// # C++ Info
82    /// - name: `meshes`(ctype: `hkArray<hkxMesh*>`)
83    /// - offset: ` 60`(x86)/` 96`(x86_64)
84    /// - type_size: ` 12`(x86)/` 16`(x86_64)
85    #[cfg_attr(feature = "json_schema", schemars(rename = "meshes"))]
86    #[cfg_attr(feature = "serde", serde(rename = "meshes"))]
87    pub m_meshes: Vec<Pointer>,
88    /// # C++ Info
89    /// - name: `materials`(ctype: `hkArray<hkxMaterial*>`)
90    /// - offset: ` 72`(x86)/`112`(x86_64)
91    /// - type_size: ` 12`(x86)/` 16`(x86_64)
92    #[cfg_attr(feature = "json_schema", schemars(rename = "materials"))]
93    #[cfg_attr(feature = "serde", serde(rename = "materials"))]
94    pub m_materials: Vec<Pointer>,
95    /// # C++ Info
96    /// - name: `inplaceTextures`(ctype: `hkArray<hkxTextureInplace*>`)
97    /// - offset: ` 84`(x86)/`128`(x86_64)
98    /// - type_size: ` 12`(x86)/` 16`(x86_64)
99    #[cfg_attr(feature = "json_schema", schemars(rename = "inplaceTextures"))]
100    #[cfg_attr(feature = "serde", serde(rename = "inplaceTextures"))]
101    pub m_inplaceTextures: Vec<Pointer>,
102    /// # C++ Info
103    /// - name: `externalTextures`(ctype: `hkArray<hkxTextureFile*>`)
104    /// - offset: ` 96`(x86)/`144`(x86_64)
105    /// - type_size: ` 12`(x86)/` 16`(x86_64)
106    #[cfg_attr(feature = "json_schema", schemars(rename = "externalTextures"))]
107    #[cfg_attr(feature = "serde", serde(rename = "externalTextures"))]
108    pub m_externalTextures: Vec<Pointer>,
109    /// # C++ Info
110    /// - name: `skinBindings`(ctype: `hkArray<hkxSkinBinding*>`)
111    /// - offset: `108`(x86)/`160`(x86_64)
112    /// - type_size: ` 12`(x86)/` 16`(x86_64)
113    #[cfg_attr(feature = "json_schema", schemars(rename = "skinBindings"))]
114    #[cfg_attr(feature = "serde", serde(rename = "skinBindings"))]
115    pub m_skinBindings: Vec<Pointer>,
116    /// # C++ Info
117    /// - name: `appliedTransform`(ctype: `hkMatrix3`)
118    /// - offset: `128`(x86)/`176`(x86_64)
119    /// - type_size: ` 48`(x86)/` 48`(x86_64)
120    #[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                /// Intended for use in XML.
248                #[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};
havok_classes/generated/hkxScene_.rs

havok_classes/generated/
hkxScene_.rs
