1use super::class_requires::*;
2use super::*;
3#[allow(non_upper_case_globals, non_snake_case)]
10#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12#[derive(educe::Educe)]
13#[educe(Debug, Clone, Default, PartialEq)]
14pub struct hkMemoryMeshTexture<'a> {
15 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[cfg_attr(feature = "json_schema", schemars(flatten))]
28 #[cfg_attr(feature = "serde", serde(flatten))]
29 pub parent: hkMeshTexture,
30 #[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 #[cfg_attr(feature = "json_schema", schemars(rename = "data"))]
43 #[cfg_attr(feature = "serde", serde(rename = "data"))]
44 pub m_data: Vec<u8>,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "format"))]
50 #[cfg_attr(feature = "serde", serde(rename = "format"))]
51 pub m_format: Format,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "hasMipMaps"))]
57 #[cfg_attr(feature = "serde", serde(rename = "hasMipMaps"))]
58 pub m_hasMipMaps: bool,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "filterMode"))]
64 #[cfg_attr(feature = "serde", serde(rename = "filterMode"))]
65 pub m_filterMode: FilterMode,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "usageHint"))]
71 #[cfg_attr(feature = "serde", serde(rename = "usageHint"))]
72 pub m_usageHint: TextureUsageType,
73 #[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 #[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};