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