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 hkpDisableEntityCollisionFilter {
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: hkpCollisionFilter,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "disabledEntities"))]
35 #[cfg_attr(feature = "serde", serde(rename = "disabledEntities"))]
36 pub m_disabledEntities: Vec<Pointer>,
37}
38const _: () = {
39 use havok_serde as _serde;
40 impl _serde::HavokClass for hkpDisableEntityCollisionFilter {
41 #[inline]
42 fn name(&self) -> &'static str {
43 "hkpDisableEntityCollisionFilter"
44 }
45 #[inline]
46 fn signature(&self) -> _serde::__private::Signature {
47 _serde::__private::Signature::new(0xfac3351c)
48 }
49 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
50 fn deps_indexes(&self) -> Vec<usize> {
51 let mut v = Vec::new();
52 v.extend(self.m_disabledEntities.iter().map(|ptr| ptr.get()));
53 v
54 }
55 }
56 impl _serde::Serialize for hkpDisableEntityCollisionFilter {
57 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
58 where
59 S: _serde::ser::Serializer,
60 {
61 let class_meta = self
62 .__ptr
63 .map(|name| (name, _serde::__private::Signature::new(0xfac3351c)));
64 let mut serializer = __serializer
65 .serialize_struct(
66 "hkpDisableEntityCollisionFilter",
67 class_meta,
68 (64u64, 96u64),
69 )?;
70 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
71 serializer
72 .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
73 serializer
74 .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
75 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
76 serializer.pad_field([0u8; 16usize].as_slice(), [0u8; 32usize].as_slice())?;
77 serializer
78 .serialize_fixed_array_field(
79 "prepad",
80 self.parent.m_prepad.as_slice(),
81 TypeSize::NonPtr,
82 )?;
83 serializer.serialize_field("type", &self.parent.m_type)?;
84 serializer
85 .serialize_fixed_array_field(
86 "postpad",
87 self.parent.m_postpad.as_slice(),
88 TypeSize::NonPtr,
89 )?;
90 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
91 serializer
92 .serialize_array_field(
93 "disabledEntities",
94 &self.m_disabledEntities,
95 TypeSize::NonPtr,
96 )?;
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 hkpDisableEntityCollisionFilter {
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_prepad,
114 m_type,
115 m_postpad,
116 m_disabledEntities,
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 "prepad" => Ok(__Field::m_prepad),
141 "type" => Ok(__Field::m_type),
142 "postpad" => Ok(__Field::m_postpad),
143 "disabledEntities" => Ok(__Field::m_disabledEntities),
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 __hkpDisableEntityCollisionFilterVisitor<'de> {
160 marker: _serde::__private::PhantomData<hkpDisableEntityCollisionFilter>,
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 __hkpDisableEntityCollisionFilterVisitor<'de> {
168 type Value = hkpDisableEntityCollisionFilter;
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 hkpDisableEntityCollisionFilter",
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_disabledEntities: _serde::__private::Option<
188 Vec<Pointer>,
189 > = _serde::__private::None;
190 for i in 0..1usize {
191 match i {
192 0usize => {
193 if _serde::__private::Option::is_some(&m_disabledEntities) {
194 return _serde::__private::Err(
195 <__A::Error as _serde::de::Error>::duplicate_field(
196 "disabledEntities",
197 ),
198 );
199 }
200 __A::pad(&mut __map, 4usize, 8usize)?;
201 m_disabledEntities = _serde::__private::Some(
202 match __A::next_value::<Vec<Pointer>>(&mut __map) {
203 _serde::__private::Ok(__val) => __val,
204 _serde::__private::Err(__err) => {
205 return _serde::__private::Err(__err);
206 }
207 },
208 );
209 }
210 _ => {}
211 }
212 }
213 let m_disabledEntities = match m_disabledEntities {
214 _serde::__private::Some(__field) => __field,
215 _serde::__private::None => {
216 return _serde::__private::Err(
217 <__A::Error as _serde::de::Error>::missing_field(
218 "disabledEntities",
219 ),
220 );
221 }
222 };
223 _serde::__private::Ok(hkpDisableEntityCollisionFilter {
224 __ptr,
225 parent,
226 m_disabledEntities,
227 })
228 }
229 #[allow(clippy::manual_unwrap_or_default)]
230 fn visit_struct<__A>(
231 self,
232 mut __map: __A,
233 ) -> _serde::__private::Result<Self::Value, __A::Error>
234 where
235 __A: _serde::de::MapAccess<'de>,
236 {
237 let mut m_prepad: _serde::__private::Option<[u32; 2usize]> = _serde::__private::None;
238 let mut m_type: _serde::__private::Option<hkpFilterType> = _serde::__private::None;
239 let mut m_postpad: _serde::__private::Option<[u32; 3usize]> = _serde::__private::None;
240 let mut m_disabledEntities: _serde::__private::Option<
241 Vec<Pointer>,
242 > = _serde::__private::None;
243 while let _serde::__private::Some(__key) = {
244 __A::next_key::<__Field>(&mut __map)?
245 } {
246 match __key {
247 __Field::m_prepad => {
248 #[cfg(
249 any(feature = "strict", feature = "ignore_duplicates")
250 )]
251 if _serde::__private::Option::is_some(&m_prepad) {
252 #[cfg(feature = "ignore_duplicates")]
253 {
254 __A::skip_value(&mut __map)?;
255 continue;
256 }
257 #[cfg(feature = "strict")]
258 return _serde::__private::Err(
259 <__A::Error as _serde::de::Error>::duplicate_field("prepad"),
260 );
261 }
262 m_prepad = _serde::__private::Some(
263 match __A::next_value::<[u32; 2usize]>(&mut __map) {
264 _serde::__private::Ok(__val) => __val,
265 _serde::__private::Err(__err) => {
266 return _serde::__private::Err(__err);
267 }
268 },
269 );
270 }
271 __Field::m_type => {
272 #[cfg(
273 any(feature = "strict", feature = "ignore_duplicates")
274 )]
275 if _serde::__private::Option::is_some(&m_type) {
276 #[cfg(feature = "ignore_duplicates")]
277 {
278 __A::skip_value(&mut __map)?;
279 continue;
280 }
281 #[cfg(feature = "strict")]
282 return _serde::__private::Err(
283 <__A::Error as _serde::de::Error>::duplicate_field("type"),
284 );
285 }
286 m_type = _serde::__private::Some(
287 match __A::next_value::<hkpFilterType>(&mut __map) {
288 _serde::__private::Ok(__val) => __val,
289 _serde::__private::Err(__err) => {
290 return _serde::__private::Err(__err);
291 }
292 },
293 );
294 }
295 __Field::m_postpad => {
296 #[cfg(
297 any(feature = "strict", feature = "ignore_duplicates")
298 )]
299 if _serde::__private::Option::is_some(&m_postpad) {
300 #[cfg(feature = "ignore_duplicates")]
301 {
302 __A::skip_value(&mut __map)?;
303 continue;
304 }
305 #[cfg(feature = "strict")]
306 return _serde::__private::Err(
307 <__A::Error as _serde::de::Error>::duplicate_field(
308 "postpad",
309 ),
310 );
311 }
312 m_postpad = _serde::__private::Some(
313 match __A::next_value::<[u32; 3usize]>(&mut __map) {
314 _serde::__private::Ok(__val) => __val,
315 _serde::__private::Err(__err) => {
316 return _serde::__private::Err(__err);
317 }
318 },
319 );
320 }
321 __Field::m_disabledEntities => {
322 #[cfg(
323 any(feature = "strict", feature = "ignore_duplicates")
324 )]
325 if _serde::__private::Option::is_some(&m_disabledEntities) {
326 #[cfg(feature = "ignore_duplicates")]
327 {
328 __A::skip_value(&mut __map)?;
329 continue;
330 }
331 #[cfg(feature = "strict")]
332 return _serde::__private::Err(
333 <__A::Error as _serde::de::Error>::duplicate_field(
334 "disabledEntities",
335 ),
336 );
337 }
338 m_disabledEntities = _serde::__private::Some(
339 match __A::next_value::<Vec<Pointer>>(&mut __map) {
340 _serde::__private::Ok(__val) => __val,
341 _serde::__private::Err(__err) => {
342 return _serde::__private::Err(__err);
343 }
344 },
345 );
346 }
347 _ => __A::skip_value(&mut __map)?,
348 }
349 }
350 let m_prepad = match m_prepad {
351 _serde::__private::Some(__field) => __field,
352 _serde::__private::None => {
353 #[cfg(feature = "strict")]
354 return _serde::__private::Err(
355 <__A::Error as _serde::de::Error>::missing_field("prepad"),
356 );
357 #[cfg(not(feature = "strict"))] Default::default()
358 }
359 };
360 let m_type = match m_type {
361 _serde::__private::Some(__field) => __field,
362 _serde::__private::None => {
363 #[cfg(feature = "strict")]
364 return _serde::__private::Err(
365 <__A::Error as _serde::de::Error>::missing_field("type"),
366 );
367 #[cfg(not(feature = "strict"))] Default::default()
368 }
369 };
370 let m_postpad = match m_postpad {
371 _serde::__private::Some(__field) => __field,
372 _serde::__private::None => {
373 #[cfg(feature = "strict")]
374 return _serde::__private::Err(
375 <__A::Error as _serde::de::Error>::missing_field("postpad"),
376 );
377 #[cfg(not(feature = "strict"))] Default::default()
378 }
379 };
380 let m_disabledEntities = match m_disabledEntities {
381 _serde::__private::Some(__field) => __field,
382 _serde::__private::None => {
383 #[cfg(feature = "strict")]
384 return _serde::__private::Err(
385 <__A::Error as _serde::de::Error>::missing_field(
386 "disabledEntities",
387 ),
388 );
389 #[cfg(not(feature = "strict"))] Default::default()
390 }
391 };
392 let __ptr = None;
393 let parent = hkBaseObject { __ptr };
394 let parent = hkReferencedObject {
395 __ptr,
396 parent,
397 ..Default::default()
398 };
399 let parent = hkpCollisionFilter {
400 __ptr,
401 parent,
402 m_prepad,
403 m_type,
404 m_postpad,
405 };
406 let __ptr = __A::class_ptr(&mut __map);
407 _serde::__private::Ok(hkpDisableEntityCollisionFilter {
408 __ptr,
409 parent,
410 m_disabledEntities,
411 })
412 }
413 }
414 const FIELDS: &[&str] = &["disabledEntities"];
415 _serde::Deserializer::deserialize_struct(
416 deserializer,
417 "hkpDisableEntityCollisionFilter",
418 FIELDS,
419 __hkpDisableEntityCollisionFilterVisitor {
420 marker: _serde::__private::PhantomData::<
421 hkpDisableEntityCollisionFilter,
422 >,
423 lifetime: _serde::__private::PhantomData,
424 },
425 )
426 }
427 }
428};