havok_classes/generated/
hkIndexedTransformSet_.rs

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

havok_classes/generated/
hkIndexedTransformSet_.rs
