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