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