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 hkpLinearParametricCurve {
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: hkpParametricCurve,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "smoothingFactor"))]
35 #[cfg_attr(feature = "serde", serde(rename = "smoothingFactor"))]
36 pub m_smoothingFactor: f32,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "closedLoop"))]
42 #[cfg_attr(feature = "serde", serde(rename = "closedLoop"))]
43 pub m_closedLoop: bool,
44 #[cfg_attr(
49 feature = "json_schema",
50 schemars(rename = "dirNotParallelToTangentAlongWholePath")
51 )]
52 #[cfg_attr(
53 feature = "serde",
54 serde(rename = "dirNotParallelToTangentAlongWholePath")
55 )]
56 pub m_dirNotParallelToTangentAlongWholePath: Vector4,
57 #[cfg_attr(feature = "json_schema", schemars(rename = "points"))]
62 #[cfg_attr(feature = "serde", serde(rename = "points"))]
63 pub m_points: Vec<Vector4>,
64 #[cfg_attr(feature = "json_schema", schemars(rename = "distance"))]
69 #[cfg_attr(feature = "serde", serde(rename = "distance"))]
70 pub m_distance: Vec<f32>,
71}
72const _: () = {
73 use havok_serde as _serde;
74 impl _serde::HavokClass for hkpLinearParametricCurve {
75 #[inline]
76 fn name(&self) -> &'static str {
77 "hkpLinearParametricCurve"
78 }
79 #[inline]
80 fn signature(&self) -> _serde::__private::Signature {
81 _serde::__private::Signature::new(0xd7b3be03)
82 }
83 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
84 fn deps_indexes(&self) -> Vec<usize> {
85 let mut v = Vec::new();
86 v
87 }
88 }
89 impl _serde::Serialize for hkpLinearParametricCurve {
90 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
91 where
92 S: _serde::ser::Serializer,
93 {
94 let class_meta = self
95 .__ptr
96 .map(|name| (name, _serde::__private::Signature::new(0xd7b3be03)));
97 let mut serializer = __serializer
98 .serialize_struct(
99 "hkpLinearParametricCurve",
100 class_meta,
101 (64u64, 80u64),
102 )?;
103 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
104 serializer
105 .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
106 serializer
107 .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
108 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
109 serializer.serialize_field("smoothingFactor", &self.m_smoothingFactor)?;
110 serializer.serialize_field("closedLoop", &self.m_closedLoop)?;
111 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 11usize].as_slice())?;
112 serializer
113 .serialize_field(
114 "dirNotParallelToTangentAlongWholePath",
115 &self.m_dirNotParallelToTangentAlongWholePath,
116 )?;
117 serializer
118 .serialize_array_field("points", &self.m_points, TypeSize::NonPtr)?;
119 serializer
120 .serialize_array_field("distance", &self.m_distance, TypeSize::NonPtr)?;
121 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
122 serializer.end()
123 }
124 }
125};
126#[doc(hidden)]
127#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
128const _: () = {
129 use havok_serde as _serde;
130 #[automatically_derived]
131 impl<'de> _serde::Deserialize<'de> for hkpLinearParametricCurve {
132 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
133 where
134 __D: _serde::Deserializer<'de>,
135 {
136 #[allow(non_camel_case_types)]
137 enum __Field {
138 m_smoothingFactor,
139 m_closedLoop,
140 m_dirNotParallelToTangentAlongWholePath,
141 m_points,
142 m_distance,
143 __ignore,
144 }
145 struct __FieldVisitor;
146 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
147 type Value = __Field;
148 fn expecting(
149 &self,
150 __formatter: &mut core::fmt::Formatter,
151 ) -> core::fmt::Result {
152 core::fmt::Formatter::write_str(__formatter, "field identifier")
153 }
154 #[allow(clippy::match_single_binding)]
156 #[allow(clippy::reversed_empty_ranges)]
157 #[allow(clippy::single_match)]
158 fn visit_key<__E>(
159 self,
160 __value: &str,
161 ) -> core::result::Result<Self::Value, __E>
162 where
163 __E: _serde::de::Error,
164 {
165 match __value {
166 "smoothingFactor" => Ok(__Field::m_smoothingFactor),
167 "closedLoop" => Ok(__Field::m_closedLoop),
168 "dirNotParallelToTangentAlongWholePath" => {
169 Ok(__Field::m_dirNotParallelToTangentAlongWholePath)
170 }
171 "points" => Ok(__Field::m_points),
172 "distance" => Ok(__Field::m_distance),
173 _ => Ok(__Field::__ignore),
174 }
175 }
176 }
177 impl<'de> _serde::Deserialize<'de> for __Field {
178 #[inline]
179 fn deserialize<__D>(
180 __deserializer: __D,
181 ) -> core::result::Result<Self, __D::Error>
182 where
183 __D: _serde::Deserializer<'de>,
184 {
185 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
186 }
187 }
188 struct __hkpLinearParametricCurveVisitor<'de> {
189 marker: _serde::__private::PhantomData<hkpLinearParametricCurve>,
190 lifetime: _serde::__private::PhantomData<&'de ()>,
191 }
192 #[allow(clippy::match_single_binding)]
193 #[allow(clippy::reversed_empty_ranges)]
194 #[allow(clippy::single_match)]
195 impl<'de> _serde::de::Visitor<'de>
196 for __hkpLinearParametricCurveVisitor<'de> {
197 type Value = hkpLinearParametricCurve;
198 fn expecting(
199 &self,
200 __formatter: &mut core::fmt::Formatter,
201 ) -> core::fmt::Result {
202 core::fmt::Formatter::write_str(
203 __formatter,
204 "struct hkpLinearParametricCurve",
205 )
206 }
207 fn visit_struct_for_bytes<__A>(
208 self,
209 mut __map: __A,
210 ) -> _serde::__private::Result<Self::Value, __A::Error>
211 where
212 __A: _serde::de::MapAccess<'de>,
213 {
214 let __ptr = __A::class_ptr(&mut __map);
215 let parent = __A::parent_value(&mut __map)?;
216 let mut m_smoothingFactor: _serde::__private::Option<f32> = _serde::__private::None;
217 let mut m_closedLoop: _serde::__private::Option<bool> = _serde::__private::None;
218 let mut m_dirNotParallelToTangentAlongWholePath: _serde::__private::Option<
219 Vector4,
220 > = _serde::__private::None;
221 let mut m_points: _serde::__private::Option<Vec<Vector4>> = _serde::__private::None;
222 let mut m_distance: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
223 for i in 0..5usize {
224 match i {
225 0usize => {
226 if _serde::__private::Option::is_some(&m_smoothingFactor) {
227 return _serde::__private::Err(
228 <__A::Error as _serde::de::Error>::duplicate_field(
229 "smoothingFactor",
230 ),
231 );
232 }
233 m_smoothingFactor = _serde::__private::Some(
234 match __A::next_value::<f32>(&mut __map) {
235 _serde::__private::Ok(__val) => __val,
236 _serde::__private::Err(__err) => {
237 return _serde::__private::Err(__err);
238 }
239 },
240 );
241 }
242 1usize => {
243 if _serde::__private::Option::is_some(&m_closedLoop) {
244 return _serde::__private::Err(
245 <__A::Error as _serde::de::Error>::duplicate_field(
246 "closedLoop",
247 ),
248 );
249 }
250 m_closedLoop = _serde::__private::Some(
251 match __A::next_value::<bool>(&mut __map) {
252 _serde::__private::Ok(__val) => __val,
253 _serde::__private::Err(__err) => {
254 return _serde::__private::Err(__err);
255 }
256 },
257 );
258 }
259 2usize => {
260 if _serde::__private::Option::is_some(
261 &m_dirNotParallelToTangentAlongWholePath,
262 ) {
263 return _serde::__private::Err(
264 <__A::Error as _serde::de::Error>::duplicate_field(
265 "dirNotParallelToTangentAlongWholePath",
266 ),
267 );
268 }
269 __A::pad(&mut __map, 3usize, 11usize)?;
270 m_dirNotParallelToTangentAlongWholePath = _serde::__private::Some(
271 match __A::next_value::<Vector4>(&mut __map) {
272 _serde::__private::Ok(__val) => __val,
273 _serde::__private::Err(__err) => {
274 return _serde::__private::Err(__err);
275 }
276 },
277 );
278 }
279 3usize => {
280 if _serde::__private::Option::is_some(&m_points) {
281 return _serde::__private::Err(
282 <__A::Error as _serde::de::Error>::duplicate_field("points"),
283 );
284 }
285 m_points = _serde::__private::Some(
286 match __A::next_value::<Vec<Vector4>>(&mut __map) {
287 _serde::__private::Ok(__val) => __val,
288 _serde::__private::Err(__err) => {
289 return _serde::__private::Err(__err);
290 }
291 },
292 );
293 }
294 4usize => {
295 if _serde::__private::Option::is_some(&m_distance) {
296 return _serde::__private::Err(
297 <__A::Error as _serde::de::Error>::duplicate_field(
298 "distance",
299 ),
300 );
301 }
302 m_distance = _serde::__private::Some(
303 match __A::next_value::<Vec<f32>>(&mut __map) {
304 _serde::__private::Ok(__val) => __val,
305 _serde::__private::Err(__err) => {
306 return _serde::__private::Err(__err);
307 }
308 },
309 );
310 }
311 _ => {}
312 }
313 }
314 __A::pad(&mut __map, 8usize, 0usize)?;
315 let m_smoothingFactor = match m_smoothingFactor {
316 _serde::__private::Some(__field) => __field,
317 _serde::__private::None => {
318 return _serde::__private::Err(
319 <__A::Error as _serde::de::Error>::missing_field(
320 "smoothingFactor",
321 ),
322 );
323 }
324 };
325 let m_closedLoop = match m_closedLoop {
326 _serde::__private::Some(__field) => __field,
327 _serde::__private::None => {
328 return _serde::__private::Err(
329 <__A::Error as _serde::de::Error>::missing_field(
330 "closedLoop",
331 ),
332 );
333 }
334 };
335 let m_dirNotParallelToTangentAlongWholePath = match m_dirNotParallelToTangentAlongWholePath {
336 _serde::__private::Some(__field) => __field,
337 _serde::__private::None => {
338 return _serde::__private::Err(
339 <__A::Error as _serde::de::Error>::missing_field(
340 "dirNotParallelToTangentAlongWholePath",
341 ),
342 );
343 }
344 };
345 let m_points = match m_points {
346 _serde::__private::Some(__field) => __field,
347 _serde::__private::None => {
348 return _serde::__private::Err(
349 <__A::Error as _serde::de::Error>::missing_field("points"),
350 );
351 }
352 };
353 let m_distance = match m_distance {
354 _serde::__private::Some(__field) => __field,
355 _serde::__private::None => {
356 return _serde::__private::Err(
357 <__A::Error as _serde::de::Error>::missing_field("distance"),
358 );
359 }
360 };
361 _serde::__private::Ok(hkpLinearParametricCurve {
362 __ptr,
363 parent,
364 m_smoothingFactor,
365 m_closedLoop,
366 m_dirNotParallelToTangentAlongWholePath,
367 m_points,
368 m_distance,
369 })
370 }
371 #[allow(clippy::manual_unwrap_or_default)]
372 fn visit_struct<__A>(
373 self,
374 mut __map: __A,
375 ) -> _serde::__private::Result<Self::Value, __A::Error>
376 where
377 __A: _serde::de::MapAccess<'de>,
378 {
379 let mut m_smoothingFactor: _serde::__private::Option<f32> = _serde::__private::None;
380 let mut m_closedLoop: _serde::__private::Option<bool> = _serde::__private::None;
381 let mut m_dirNotParallelToTangentAlongWholePath: _serde::__private::Option<
382 Vector4,
383 > = _serde::__private::None;
384 let mut m_points: _serde::__private::Option<Vec<Vector4>> = _serde::__private::None;
385 let mut m_distance: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
386 while let _serde::__private::Some(__key) = {
387 __A::next_key::<__Field>(&mut __map)?
388 } {
389 match __key {
390 __Field::m_smoothingFactor => {
391 #[cfg(
392 any(feature = "strict", feature = "ignore_duplicates")
393 )]
394 if _serde::__private::Option::is_some(&m_smoothingFactor) {
395 #[cfg(feature = "ignore_duplicates")]
396 {
397 __A::skip_value(&mut __map)?;
398 continue;
399 }
400 #[cfg(feature = "strict")]
401 return _serde::__private::Err(
402 <__A::Error as _serde::de::Error>::duplicate_field(
403 "smoothingFactor",
404 ),
405 );
406 }
407 m_smoothingFactor = _serde::__private::Some(
408 match __A::next_value::<f32>(&mut __map) {
409 _serde::__private::Ok(__val) => __val,
410 _serde::__private::Err(__err) => {
411 return _serde::__private::Err(__err);
412 }
413 },
414 );
415 }
416 __Field::m_closedLoop => {
417 #[cfg(
418 any(feature = "strict", feature = "ignore_duplicates")
419 )]
420 if _serde::__private::Option::is_some(&m_closedLoop) {
421 #[cfg(feature = "ignore_duplicates")]
422 {
423 __A::skip_value(&mut __map)?;
424 continue;
425 }
426 #[cfg(feature = "strict")]
427 return _serde::__private::Err(
428 <__A::Error as _serde::de::Error>::duplicate_field(
429 "closedLoop",
430 ),
431 );
432 }
433 m_closedLoop = _serde::__private::Some(
434 match __A::next_value::<bool>(&mut __map) {
435 _serde::__private::Ok(__val) => __val,
436 _serde::__private::Err(__err) => {
437 return _serde::__private::Err(__err);
438 }
439 },
440 );
441 }
442 __Field::m_dirNotParallelToTangentAlongWholePath => {
443 #[cfg(
444 any(feature = "strict", feature = "ignore_duplicates")
445 )]
446 if _serde::__private::Option::is_some(
447 &m_dirNotParallelToTangentAlongWholePath,
448 ) {
449 #[cfg(feature = "ignore_duplicates")]
450 {
451 __A::skip_value(&mut __map)?;
452 continue;
453 }
454 #[cfg(feature = "strict")]
455 return _serde::__private::Err(
456 <__A::Error as _serde::de::Error>::duplicate_field(
457 "dirNotParallelToTangentAlongWholePath",
458 ),
459 );
460 }
461 m_dirNotParallelToTangentAlongWholePath = _serde::__private::Some(
462 match __A::next_value::<Vector4>(&mut __map) {
463 _serde::__private::Ok(__val) => __val,
464 _serde::__private::Err(__err) => {
465 return _serde::__private::Err(__err);
466 }
467 },
468 );
469 }
470 __Field::m_points => {
471 #[cfg(
472 any(feature = "strict", feature = "ignore_duplicates")
473 )]
474 if _serde::__private::Option::is_some(&m_points) {
475 #[cfg(feature = "ignore_duplicates")]
476 {
477 __A::skip_value(&mut __map)?;
478 continue;
479 }
480 #[cfg(feature = "strict")]
481 return _serde::__private::Err(
482 <__A::Error as _serde::de::Error>::duplicate_field("points"),
483 );
484 }
485 m_points = _serde::__private::Some(
486 match __A::next_value::<Vec<Vector4>>(&mut __map) {
487 _serde::__private::Ok(__val) => __val,
488 _serde::__private::Err(__err) => {
489 return _serde::__private::Err(__err);
490 }
491 },
492 );
493 }
494 __Field::m_distance => {
495 #[cfg(
496 any(feature = "strict", feature = "ignore_duplicates")
497 )]
498 if _serde::__private::Option::is_some(&m_distance) {
499 #[cfg(feature = "ignore_duplicates")]
500 {
501 __A::skip_value(&mut __map)?;
502 continue;
503 }
504 #[cfg(feature = "strict")]
505 return _serde::__private::Err(
506 <__A::Error as _serde::de::Error>::duplicate_field(
507 "distance",
508 ),
509 );
510 }
511 m_distance = _serde::__private::Some(
512 match __A::next_value::<Vec<f32>>(&mut __map) {
513 _serde::__private::Ok(__val) => __val,
514 _serde::__private::Err(__err) => {
515 return _serde::__private::Err(__err);
516 }
517 },
518 );
519 }
520 _ => __A::skip_value(&mut __map)?,
521 }
522 }
523 let m_smoothingFactor = match m_smoothingFactor {
524 _serde::__private::Some(__field) => __field,
525 _serde::__private::None => {
526 #[cfg(feature = "strict")]
527 return _serde::__private::Err(
528 <__A::Error as _serde::de::Error>::missing_field(
529 "smoothingFactor",
530 ),
531 );
532 #[cfg(not(feature = "strict"))] Default::default()
533 }
534 };
535 let m_closedLoop = match m_closedLoop {
536 _serde::__private::Some(__field) => __field,
537 _serde::__private::None => {
538 #[cfg(feature = "strict")]
539 return _serde::__private::Err(
540 <__A::Error as _serde::de::Error>::missing_field(
541 "closedLoop",
542 ),
543 );
544 #[cfg(not(feature = "strict"))] Default::default()
545 }
546 };
547 let m_dirNotParallelToTangentAlongWholePath = match m_dirNotParallelToTangentAlongWholePath {
548 _serde::__private::Some(__field) => __field,
549 _serde::__private::None => {
550 #[cfg(feature = "strict")]
551 return _serde::__private::Err(
552 <__A::Error as _serde::de::Error>::missing_field(
553 "dirNotParallelToTangentAlongWholePath",
554 ),
555 );
556 #[cfg(not(feature = "strict"))] Default::default()
557 }
558 };
559 let m_points = match m_points {
560 _serde::__private::Some(__field) => __field,
561 _serde::__private::None => {
562 #[cfg(feature = "strict")]
563 return _serde::__private::Err(
564 <__A::Error as _serde::de::Error>::missing_field("points"),
565 );
566 #[cfg(not(feature = "strict"))] Default::default()
567 }
568 };
569 let m_distance = match m_distance {
570 _serde::__private::Some(__field) => __field,
571 _serde::__private::None => {
572 #[cfg(feature = "strict")]
573 return _serde::__private::Err(
574 <__A::Error as _serde::de::Error>::missing_field("distance"),
575 );
576 #[cfg(not(feature = "strict"))] Default::default()
577 }
578 };
579 let __ptr = None;
580 let parent = hkBaseObject { __ptr };
581 let parent = hkReferencedObject {
582 __ptr,
583 parent,
584 ..Default::default()
585 };
586 let parent = hkpParametricCurve {
587 __ptr,
588 parent,
589 };
590 let __ptr = __A::class_ptr(&mut __map);
591 _serde::__private::Ok(hkpLinearParametricCurve {
592 __ptr,
593 parent,
594 m_smoothingFactor,
595 m_closedLoop,
596 m_dirNotParallelToTangentAlongWholePath,
597 m_points,
598 m_distance,
599 })
600 }
601 }
602 const FIELDS: &[&str] = &[
603 "smoothingFactor",
604 "closedLoop",
605 "dirNotParallelToTangentAlongWholePath",
606 "points",
607 "distance",
608 ];
609 _serde::Deserializer::deserialize_struct(
610 deserializer,
611 "hkpLinearParametricCurve",
612 FIELDS,
613 __hkpLinearParametricCurveVisitor {
614 marker: _serde::__private::PhantomData::<hkpLinearParametricCurve>,
615 lifetime: _serde::__private::PhantomData,
616 },
617 )
618 }
619 }
620};