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 hkpDisplayBindingDataPhysicsSystem {
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: hkReferencedObject,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "bindings"))]
35 #[cfg_attr(feature = "serde", serde(rename = "bindings"))]
36 pub m_bindings: Vec<Pointer>,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "system"))]
42 #[cfg_attr(feature = "serde", serde(rename = "system"))]
43 pub m_system: Pointer,
44}
45const _: () = {
46 use havok_serde as _serde;
47 impl _serde::HavokClass for hkpDisplayBindingDataPhysicsSystem {
48 #[inline]
49 fn name(&self) -> &'static str {
50 "hkpDisplayBindingDataPhysicsSystem"
51 }
52 #[inline]
53 fn signature(&self) -> _serde::__private::Signature {
54 _serde::__private::Signature::new(0xc8ae86a7)
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(self.m_bindings.iter().map(|ptr| ptr.get()));
60 v.push(self.m_system.get());
61 v
62 }
63 }
64 impl _serde::Serialize for hkpDisplayBindingDataPhysicsSystem {
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(0xc8ae86a7)));
72 let mut serializer = __serializer
73 .serialize_struct(
74 "hkpDisplayBindingDataPhysicsSystem",
75 class_meta,
76 (24u64, 40u64),
77 )?;
78 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
79 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
80 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
81 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
82 serializer
83 .serialize_array_field("bindings", &self.m_bindings, TypeSize::NonPtr)?;
84 serializer.serialize_field("system", &self.m_system)?;
85 serializer.end()
86 }
87 }
88};
89#[doc(hidden)]
90#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
91const _: () = {
92 use havok_serde as _serde;
93 #[automatically_derived]
94 impl<'de> _serde::Deserialize<'de> for hkpDisplayBindingDataPhysicsSystem {
95 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
96 where
97 __D: _serde::Deserializer<'de>,
98 {
99 #[allow(non_camel_case_types)]
100 enum __Field {
101 m_bindings,
102 m_system,
103 __ignore,
104 }
105 struct __FieldVisitor;
106 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
107 type Value = __Field;
108 fn expecting(
109 &self,
110 __formatter: &mut core::fmt::Formatter,
111 ) -> core::fmt::Result {
112 core::fmt::Formatter::write_str(__formatter, "field identifier")
113 }
114 #[allow(clippy::match_single_binding)]
116 #[allow(clippy::reversed_empty_ranges)]
117 #[allow(clippy::single_match)]
118 fn visit_key<__E>(
119 self,
120 __value: &str,
121 ) -> core::result::Result<Self::Value, __E>
122 where
123 __E: _serde::de::Error,
124 {
125 match __value {
126 "bindings" => Ok(__Field::m_bindings),
127 "system" => Ok(__Field::m_system),
128 _ => Ok(__Field::__ignore),
129 }
130 }
131 }
132 impl<'de> _serde::Deserialize<'de> for __Field {
133 #[inline]
134 fn deserialize<__D>(
135 __deserializer: __D,
136 ) -> core::result::Result<Self, __D::Error>
137 where
138 __D: _serde::Deserializer<'de>,
139 {
140 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
141 }
142 }
143 struct __hkpDisplayBindingDataPhysicsSystemVisitor<'de> {
144 marker: _serde::__private::PhantomData<
145 hkpDisplayBindingDataPhysicsSystem,
146 >,
147 lifetime: _serde::__private::PhantomData<&'de ()>,
148 }
149 #[allow(clippy::match_single_binding)]
150 #[allow(clippy::reversed_empty_ranges)]
151 #[allow(clippy::single_match)]
152 impl<'de> _serde::de::Visitor<'de>
153 for __hkpDisplayBindingDataPhysicsSystemVisitor<'de> {
154 type Value = hkpDisplayBindingDataPhysicsSystem;
155 fn expecting(
156 &self,
157 __formatter: &mut core::fmt::Formatter,
158 ) -> core::fmt::Result {
159 core::fmt::Formatter::write_str(
160 __formatter,
161 "struct hkpDisplayBindingDataPhysicsSystem",
162 )
163 }
164 fn visit_struct_for_bytes<__A>(
165 self,
166 mut __map: __A,
167 ) -> _serde::__private::Result<Self::Value, __A::Error>
168 where
169 __A: _serde::de::MapAccess<'de>,
170 {
171 let __ptr = __A::class_ptr(&mut __map);
172 let parent = __A::parent_value(&mut __map)?;
173 let mut m_bindings: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
174 let mut m_system: _serde::__private::Option<Pointer> = _serde::__private::None;
175 for i in 0..2usize {
176 match i {
177 0usize => {
178 if _serde::__private::Option::is_some(&m_bindings) {
179 return _serde::__private::Err(
180 <__A::Error as _serde::de::Error>::duplicate_field(
181 "bindings",
182 ),
183 );
184 }
185 m_bindings = _serde::__private::Some(
186 match __A::next_value::<Vec<Pointer>>(&mut __map) {
187 _serde::__private::Ok(__val) => __val,
188 _serde::__private::Err(__err) => {
189 return _serde::__private::Err(__err);
190 }
191 },
192 );
193 }
194 1usize => {
195 if _serde::__private::Option::is_some(&m_system) {
196 return _serde::__private::Err(
197 <__A::Error as _serde::de::Error>::duplicate_field("system"),
198 );
199 }
200 m_system = _serde::__private::Some(
201 match __A::next_value::<Pointer>(&mut __map) {
202 _serde::__private::Ok(__val) => __val,
203 _serde::__private::Err(__err) => {
204 return _serde::__private::Err(__err);
205 }
206 },
207 );
208 }
209 _ => {}
210 }
211 }
212 let m_bindings = match m_bindings {
213 _serde::__private::Some(__field) => __field,
214 _serde::__private::None => {
215 return _serde::__private::Err(
216 <__A::Error as _serde::de::Error>::missing_field("bindings"),
217 );
218 }
219 };
220 let m_system = match m_system {
221 _serde::__private::Some(__field) => __field,
222 _serde::__private::None => {
223 return _serde::__private::Err(
224 <__A::Error as _serde::de::Error>::missing_field("system"),
225 );
226 }
227 };
228 _serde::__private::Ok(hkpDisplayBindingDataPhysicsSystem {
229 __ptr,
230 parent,
231 m_bindings,
232 m_system,
233 })
234 }
235 #[allow(clippy::manual_unwrap_or_default)]
236 fn visit_struct<__A>(
237 self,
238 mut __map: __A,
239 ) -> _serde::__private::Result<Self::Value, __A::Error>
240 where
241 __A: _serde::de::MapAccess<'de>,
242 {
243 let mut m_bindings: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
244 let mut m_system: _serde::__private::Option<Pointer> = _serde::__private::None;
245 while let _serde::__private::Some(__key) = {
246 __A::next_key::<__Field>(&mut __map)?
247 } {
248 match __key {
249 __Field::m_bindings => {
250 #[cfg(
251 any(feature = "strict", feature = "ignore_duplicates")
252 )]
253 if _serde::__private::Option::is_some(&m_bindings) {
254 #[cfg(feature = "ignore_duplicates")]
255 {
256 __A::skip_value(&mut __map)?;
257 continue;
258 }
259 #[cfg(feature = "strict")]
260 return _serde::__private::Err(
261 <__A::Error as _serde::de::Error>::duplicate_field(
262 "bindings",
263 ),
264 );
265 }
266 m_bindings = _serde::__private::Some(
267 match __A::next_value::<Vec<Pointer>>(&mut __map) {
268 _serde::__private::Ok(__val) => __val,
269 _serde::__private::Err(__err) => {
270 return _serde::__private::Err(__err);
271 }
272 },
273 );
274 }
275 __Field::m_system => {
276 #[cfg(
277 any(feature = "strict", feature = "ignore_duplicates")
278 )]
279 if _serde::__private::Option::is_some(&m_system) {
280 #[cfg(feature = "ignore_duplicates")]
281 {
282 __A::skip_value(&mut __map)?;
283 continue;
284 }
285 #[cfg(feature = "strict")]
286 return _serde::__private::Err(
287 <__A::Error as _serde::de::Error>::duplicate_field("system"),
288 );
289 }
290 m_system = _serde::__private::Some(
291 match __A::next_value::<Pointer>(&mut __map) {
292 _serde::__private::Ok(__val) => __val,
293 _serde::__private::Err(__err) => {
294 return _serde::__private::Err(__err);
295 }
296 },
297 );
298 }
299 _ => __A::skip_value(&mut __map)?,
300 }
301 }
302 let m_bindings = match m_bindings {
303 _serde::__private::Some(__field) => __field,
304 _serde::__private::None => {
305 #[cfg(feature = "strict")]
306 return _serde::__private::Err(
307 <__A::Error as _serde::de::Error>::missing_field("bindings"),
308 );
309 #[cfg(not(feature = "strict"))] Default::default()
310 }
311 };
312 let m_system = match m_system {
313 _serde::__private::Some(__field) => __field,
314 _serde::__private::None => {
315 #[cfg(feature = "strict")]
316 return _serde::__private::Err(
317 <__A::Error as _serde::de::Error>::missing_field("system"),
318 );
319 #[cfg(not(feature = "strict"))] Default::default()
320 }
321 };
322 let __ptr = None;
323 let parent = hkBaseObject { __ptr };
324 let parent = hkReferencedObject {
325 __ptr,
326 parent,
327 ..Default::default()
328 };
329 let __ptr = __A::class_ptr(&mut __map);
330 _serde::__private::Ok(hkpDisplayBindingDataPhysicsSystem {
331 __ptr,
332 parent,
333 m_bindings,
334 m_system,
335 })
336 }
337 }
338 const FIELDS: &[&str] = &["bindings", "system"];
339 _serde::Deserializer::deserialize_struct(
340 deserializer,
341 "hkpDisplayBindingDataPhysicsSystem",
342 FIELDS,
343 __hkpDisplayBindingDataPhysicsSystemVisitor {
344 marker: _serde::__private::PhantomData::<
345 hkpDisplayBindingDataPhysicsSystem,
346 >,
347 lifetime: _serde::__private::PhantomData,
348 },
349 )
350 }
351 }
352};