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