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