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