havok_classes/generated/
hkxTextureInplace_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkxTextureInplace`
5/// - version: `1`
6/// - signature: `0xd45841d6`
7/// - size: ` 32`(x86)/` 56`(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 hkxTextureInplace<'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: `fileType`(ctype: `hkChar[4]`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: `  4`(x86)/`  4`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "fileType"))]
35    #[cfg_attr(feature = "serde", serde(rename = "fileType"))]
36    pub m_fileType: [char; 4usize],
37    /// # C++ Info
38    /// - name: `data`(ctype: `hkArray<hkUint8>`)
39    /// - offset: ` 12`(x86)/` 24`(x86_64)
40    /// - type_size: ` 12`(x86)/` 16`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "data"))]
42    #[cfg_attr(feature = "serde", serde(rename = "data"))]
43    pub m_data: Vec<u8>,
44    /// # C++ Info
45    /// - name: `name`(ctype: `hkStringPtr`)
46    /// - offset: ` 24`(x86)/` 40`(x86_64)
47    /// - type_size: `  4`(x86)/`  8`(x86_64)
48    #[cfg_attr(feature = "serde", serde(borrow))]
49    #[cfg_attr(feature = "json_schema", schemars(rename = "name"))]
50    #[cfg_attr(feature = "serde", serde(rename = "name"))]
51    pub m_name: StringPtr<'a>,
52    /// # C++ Info
53    /// - name: `originalFilename`(ctype: `hkStringPtr`)
54    /// - offset: ` 28`(x86)/` 48`(x86_64)
55    /// - type_size: `  4`(x86)/`  8`(x86_64)
56    #[cfg_attr(feature = "serde", serde(borrow))]
57    #[cfg_attr(feature = "json_schema", schemars(rename = "originalFilename"))]
58    #[cfg_attr(feature = "serde", serde(rename = "originalFilename"))]
59    pub m_originalFilename: StringPtr<'a>,
60}
61const _: () = {
62    use havok_serde as _serde;
63    impl<'a> _serde::HavokClass for hkxTextureInplace<'a> {
64        #[inline]
65        fn name(&self) -> &'static str {
66            "hkxTextureInplace"
67        }
68        #[inline]
69        fn signature(&self) -> _serde::__private::Signature {
70            _serde::__private::Signature::new(0xd45841d6)
71        }
72        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
73        fn deps_indexes(&self) -> Vec<usize> {
74            let mut v = Vec::new();
75            v
76        }
77    }
78    impl<'a> _serde::Serialize for hkxTextureInplace<'a> {
79        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
80        where
81            S: _serde::ser::Serializer,
82        {
83            let class_meta = self
84                .__ptr
85                .map(|name| (name, _serde::__private::Signature::new(0xd45841d6)));
86            let mut serializer = __serializer
87                .serialize_struct("hkxTextureInplace", class_meta, (32u64, 56u64))?;
88            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
89            serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
90            serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
91            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
92            serializer
93                .serialize_fixed_array_field(
94                    "fileType",
95                    self.m_fileType.as_slice(),
96                    TypeSize::NonPtr,
97                )?;
98            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
99            serializer.serialize_array_field("data", &self.m_data, TypeSize::NonPtr)?;
100            serializer.serialize_field("name", &self.m_name)?;
101            serializer.serialize_field("originalFilename", &self.m_originalFilename)?;
102            serializer.end()
103        }
104    }
105};
106#[doc(hidden)]
107#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
108const _: () = {
109    use havok_serde as _serde;
110    #[automatically_derived]
111    impl<'de> _serde::Deserialize<'de> for hkxTextureInplace<'de> {
112        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
113        where
114            __D: _serde::Deserializer<'de>,
115        {
116            #[allow(non_camel_case_types)]
117            enum __Field {
118                m_fileType,
119                m_data,
120                m_name,
121                m_originalFilename,
122                __ignore,
123            }
124            struct __FieldVisitor;
125            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
126                type Value = __Field;
127                fn expecting(
128                    &self,
129                    __formatter: &mut core::fmt::Formatter,
130                ) -> core::fmt::Result {
131                    core::fmt::Formatter::write_str(__formatter, "field identifier")
132                }
133                /// Intended for use in XML.
134                #[allow(clippy::match_single_binding)]
135                #[allow(clippy::reversed_empty_ranges)]
136                #[allow(clippy::single_match)]
137                fn visit_key<__E>(
138                    self,
139                    __value: &str,
140                ) -> core::result::Result<Self::Value, __E>
141                where
142                    __E: _serde::de::Error,
143                {
144                    match __value {
145                        "fileType" => Ok(__Field::m_fileType),
146                        "data" => Ok(__Field::m_data),
147                        "name" => Ok(__Field::m_name),
148                        "originalFilename" => Ok(__Field::m_originalFilename),
149                        _ => Ok(__Field::__ignore),
150                    }
151                }
152            }
153            impl<'de> _serde::Deserialize<'de> for __Field {
154                #[inline]
155                fn deserialize<__D>(
156                    __deserializer: __D,
157                ) -> core::result::Result<Self, __D::Error>
158                where
159                    __D: _serde::Deserializer<'de>,
160                {
161                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
162                }
163            }
164            struct __hkxTextureInplaceVisitor<'de> {
165                marker: _serde::__private::PhantomData<hkxTextureInplace<'de>>,
166                lifetime: _serde::__private::PhantomData<&'de ()>,
167            }
168            #[allow(clippy::match_single_binding)]
169            #[allow(clippy::reversed_empty_ranges)]
170            #[allow(clippy::single_match)]
171            impl<'de> _serde::de::Visitor<'de> for __hkxTextureInplaceVisitor<'de> {
172                type Value = hkxTextureInplace<'de>;
173                fn expecting(
174                    &self,
175                    __formatter: &mut core::fmt::Formatter,
176                ) -> core::fmt::Result {
177                    core::fmt::Formatter::write_str(
178                        __formatter,
179                        "struct hkxTextureInplace",
180                    )
181                }
182                fn visit_struct_for_bytes<__A>(
183                    self,
184                    mut __map: __A,
185                ) -> _serde::__private::Result<Self::Value, __A::Error>
186                where
187                    __A: _serde::de::MapAccess<'de>,
188                {
189                    let __ptr = __A::class_ptr(&mut __map);
190                    let parent = __A::parent_value(&mut __map)?;
191                    let mut m_fileType: _serde::__private::Option<[char; 4usize]> = _serde::__private::None;
192                    let mut m_data: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
193                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
194                    let mut m_originalFilename: _serde::__private::Option<
195                        StringPtr<'de>,
196                    > = _serde::__private::None;
197                    for i in 0..4usize {
198                        match i {
199                            0usize => {
200                                if _serde::__private::Option::is_some(&m_fileType) {
201                                    return _serde::__private::Err(
202                                        <__A::Error as _serde::de::Error>::duplicate_field(
203                                            "fileType",
204                                        ),
205                                    );
206                                }
207                                m_fileType = _serde::__private::Some(
208                                    match __A::next_value::<[char; 4usize]>(&mut __map) {
209                                        _serde::__private::Ok(__val) => __val,
210                                        _serde::__private::Err(__err) => {
211                                            return _serde::__private::Err(__err);
212                                        }
213                                    },
214                                );
215                            }
216                            1usize => {
217                                if _serde::__private::Option::is_some(&m_data) {
218                                    return _serde::__private::Err(
219                                        <__A::Error as _serde::de::Error>::duplicate_field("data"),
220                                    );
221                                }
222                                __A::pad(&mut __map, 0usize, 4usize)?;
223                                m_data = _serde::__private::Some(
224                                    match __A::next_value::<Vec<u8>>(&mut __map) {
225                                        _serde::__private::Ok(__val) => __val,
226                                        _serde::__private::Err(__err) => {
227                                            return _serde::__private::Err(__err);
228                                        }
229                                    },
230                                );
231                            }
232                            2usize => {
233                                if _serde::__private::Option::is_some(&m_name) {
234                                    return _serde::__private::Err(
235                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
236                                    );
237                                }
238                                m_name = _serde::__private::Some(
239                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
240                                        _serde::__private::Ok(__val) => __val,
241                                        _serde::__private::Err(__err) => {
242                                            return _serde::__private::Err(__err);
243                                        }
244                                    },
245                                );
246                            }
247                            3usize => {
248                                if _serde::__private::Option::is_some(&m_originalFilename) {
249                                    return _serde::__private::Err(
250                                        <__A::Error as _serde::de::Error>::duplicate_field(
251                                            "originalFilename",
252                                        ),
253                                    );
254                                }
255                                m_originalFilename = _serde::__private::Some(
256                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
257                                        _serde::__private::Ok(__val) => __val,
258                                        _serde::__private::Err(__err) => {
259                                            return _serde::__private::Err(__err);
260                                        }
261                                    },
262                                );
263                            }
264                            _ => {}
265                        }
266                    }
267                    let m_fileType = match m_fileType {
268                        _serde::__private::Some(__field) => __field,
269                        _serde::__private::None => {
270                            return _serde::__private::Err(
271                                <__A::Error as _serde::de::Error>::missing_field("fileType"),
272                            );
273                        }
274                    };
275                    let m_data = match m_data {
276                        _serde::__private::Some(__field) => __field,
277                        _serde::__private::None => {
278                            return _serde::__private::Err(
279                                <__A::Error as _serde::de::Error>::missing_field("data"),
280                            );
281                        }
282                    };
283                    let m_name = match m_name {
284                        _serde::__private::Some(__field) => __field,
285                        _serde::__private::None => {
286                            return _serde::__private::Err(
287                                <__A::Error as _serde::de::Error>::missing_field("name"),
288                            );
289                        }
290                    };
291                    let m_originalFilename = match m_originalFilename {
292                        _serde::__private::Some(__field) => __field,
293                        _serde::__private::None => {
294                            return _serde::__private::Err(
295                                <__A::Error as _serde::de::Error>::missing_field(
296                                    "originalFilename",
297                                ),
298                            );
299                        }
300                    };
301                    _serde::__private::Ok(hkxTextureInplace {
302                        __ptr,
303                        parent,
304                        m_fileType,
305                        m_data,
306                        m_name,
307                        m_originalFilename,
308                    })
309                }
310                #[allow(clippy::manual_unwrap_or_default)]
311                fn visit_struct<__A>(
312                    self,
313                    mut __map: __A,
314                ) -> _serde::__private::Result<Self::Value, __A::Error>
315                where
316                    __A: _serde::de::MapAccess<'de>,
317                {
318                    let mut m_fileType: _serde::__private::Option<[char; 4usize]> = _serde::__private::None;
319                    let mut m_data: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
320                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
321                    let mut m_originalFilename: _serde::__private::Option<
322                        StringPtr<'de>,
323                    > = _serde::__private::None;
324                    while let _serde::__private::Some(__key) = {
325                        __A::next_key::<__Field>(&mut __map)?
326                    } {
327                        match __key {
328                            __Field::m_fileType => {
329                                #[cfg(
330                                    any(feature = "strict", feature = "ignore_duplicates")
331                                )]
332                                if _serde::__private::Option::is_some(&m_fileType) {
333                                    #[cfg(feature = "ignore_duplicates")]
334                                    {
335                                        __A::skip_value(&mut __map)?;
336                                        continue;
337                                    }
338                                    #[cfg(feature = "strict")]
339                                    return _serde::__private::Err(
340                                        <__A::Error as _serde::de::Error>::duplicate_field(
341                                            "fileType",
342                                        ),
343                                    );
344                                }
345                                m_fileType = _serde::__private::Some(
346                                    match __A::next_value::<[char; 4usize]>(&mut __map) {
347                                        _serde::__private::Ok(__val) => __val,
348                                        _serde::__private::Err(__err) => {
349                                            return _serde::__private::Err(__err);
350                                        }
351                                    },
352                                );
353                            }
354                            __Field::m_data => {
355                                #[cfg(
356                                    any(feature = "strict", feature = "ignore_duplicates")
357                                )]
358                                if _serde::__private::Option::is_some(&m_data) {
359                                    #[cfg(feature = "ignore_duplicates")]
360                                    {
361                                        __A::skip_value(&mut __map)?;
362                                        continue;
363                                    }
364                                    #[cfg(feature = "strict")]
365                                    return _serde::__private::Err(
366                                        <__A::Error as _serde::de::Error>::duplicate_field("data"),
367                                    );
368                                }
369                                m_data = _serde::__private::Some(
370                                    match __A::next_value::<Vec<u8>>(&mut __map) {
371                                        _serde::__private::Ok(__val) => __val,
372                                        _serde::__private::Err(__err) => {
373                                            return _serde::__private::Err(__err);
374                                        }
375                                    },
376                                );
377                            }
378                            __Field::m_name => {
379                                #[cfg(
380                                    any(feature = "strict", feature = "ignore_duplicates")
381                                )]
382                                if _serde::__private::Option::is_some(&m_name) {
383                                    #[cfg(feature = "ignore_duplicates")]
384                                    {
385                                        __A::skip_value(&mut __map)?;
386                                        continue;
387                                    }
388                                    #[cfg(feature = "strict")]
389                                    return _serde::__private::Err(
390                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
391                                    );
392                                }
393                                m_name = _serde::__private::Some(
394                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
395                                        _serde::__private::Ok(__val) => __val,
396                                        _serde::__private::Err(__err) => {
397                                            return _serde::__private::Err(__err);
398                                        }
399                                    },
400                                );
401                            }
402                            __Field::m_originalFilename => {
403                                #[cfg(
404                                    any(feature = "strict", feature = "ignore_duplicates")
405                                )]
406                                if _serde::__private::Option::is_some(&m_originalFilename) {
407                                    #[cfg(feature = "ignore_duplicates")]
408                                    {
409                                        __A::skip_value(&mut __map)?;
410                                        continue;
411                                    }
412                                    #[cfg(feature = "strict")]
413                                    return _serde::__private::Err(
414                                        <__A::Error as _serde::de::Error>::duplicate_field(
415                                            "originalFilename",
416                                        ),
417                                    );
418                                }
419                                m_originalFilename = _serde::__private::Some(
420                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
421                                        _serde::__private::Ok(__val) => __val,
422                                        _serde::__private::Err(__err) => {
423                                            return _serde::__private::Err(__err);
424                                        }
425                                    },
426                                );
427                            }
428                            _ => __A::skip_value(&mut __map)?,
429                        }
430                    }
431                    let m_fileType = match m_fileType {
432                        _serde::__private::Some(__field) => __field,
433                        _serde::__private::None => {
434                            #[cfg(feature = "strict")]
435                            return _serde::__private::Err(
436                                <__A::Error as _serde::de::Error>::missing_field("fileType"),
437                            );
438                            #[cfg(not(feature = "strict"))] Default::default()
439                        }
440                    };
441                    let m_data = match m_data {
442                        _serde::__private::Some(__field) => __field,
443                        _serde::__private::None => {
444                            #[cfg(feature = "strict")]
445                            return _serde::__private::Err(
446                                <__A::Error as _serde::de::Error>::missing_field("data"),
447                            );
448                            #[cfg(not(feature = "strict"))] Default::default()
449                        }
450                    };
451                    let m_name = match m_name {
452                        _serde::__private::Some(__field) => __field,
453                        _serde::__private::None => {
454                            #[cfg(feature = "strict")]
455                            return _serde::__private::Err(
456                                <__A::Error as _serde::de::Error>::missing_field("name"),
457                            );
458                            #[cfg(not(feature = "strict"))] Default::default()
459                        }
460                    };
461                    let m_originalFilename = match m_originalFilename {
462                        _serde::__private::Some(__field) => __field,
463                        _serde::__private::None => {
464                            #[cfg(feature = "strict")]
465                            return _serde::__private::Err(
466                                <__A::Error as _serde::de::Error>::missing_field(
467                                    "originalFilename",
468                                ),
469                            );
470                            #[cfg(not(feature = "strict"))] Default::default()
471                        }
472                    };
473                    let __ptr = None;
474                    let parent = hkBaseObject { __ptr };
475                    let parent = hkReferencedObject {
476                        __ptr,
477                        parent,
478                        ..Default::default()
479                    };
480                    let __ptr = __A::class_ptr(&mut __map);
481                    _serde::__private::Ok(hkxTextureInplace {
482                        __ptr,
483                        parent,
484                        m_fileType,
485                        m_data,
486                        m_name,
487                        m_originalFilename,
488                    })
489                }
490            }
491            const FIELDS: &[&str] = &["fileType", "data", "name", "originalFilename"];
492            _serde::Deserializer::deserialize_struct(
493                deserializer,
494                "hkxTextureInplace",
495                FIELDS,
496                __hkxTextureInplaceVisitor {
497                    marker: _serde::__private::PhantomData::<hkxTextureInplace>,
498                    lifetime: _serde::__private::PhantomData,
499                },
500            )
501        }
502    }
503};
havok_classes/generated/hkxTextureInplace_.rs

havok_classes/generated/
hkxTextureInplace_.rs
