havok_classes/generated/
hkMemoryMeshTexture_.rs

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

havok_classes/generated/
hkMemoryMeshTexture_.rs
