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