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 hkbEvaluateHandleModifier<'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 = "handle"))]
36 #[cfg_attr(feature = "serde", serde(rename = "handle"))]
37 pub m_handle: Pointer,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "handlePositionOut"))]
43 #[cfg_attr(feature = "serde", serde(rename = "handlePositionOut"))]
44 pub m_handlePositionOut: Vector4,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "handleRotationOut"))]
50 #[cfg_attr(feature = "serde", serde(rename = "handleRotationOut"))]
51 pub m_handleRotationOut: Quaternion,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "isValidOut"))]
57 #[cfg_attr(feature = "serde", serde(rename = "isValidOut"))]
58 pub m_isValidOut: bool,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "extrapolationTimeStep"))]
64 #[cfg_attr(feature = "serde", serde(rename = "extrapolationTimeStep"))]
65 pub m_extrapolationTimeStep: f32,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "handleChangeSpeed"))]
71 #[cfg_attr(feature = "serde", serde(rename = "handleChangeSpeed"))]
72 pub m_handleChangeSpeed: f32,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "handleChangeMode"))]
78 #[cfg_attr(feature = "serde", serde(rename = "handleChangeMode"))]
79 pub m_handleChangeMode: HandleChangeMode,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "oldHandle"))]
86 #[cfg_attr(feature = "serde", serde(rename = "oldHandle"))]
87 pub m_oldHandle: hkbHandle,
88 #[cfg_attr(feature = "json_schema", schemars(rename = "oldHandlePosition"))]
94 #[cfg_attr(feature = "serde", serde(rename = "oldHandlePosition"))]
95 pub m_oldHandlePosition: Vector4,
96 #[cfg_attr(feature = "json_schema", schemars(rename = "oldHandleRotation"))]
102 #[cfg_attr(feature = "serde", serde(rename = "oldHandleRotation"))]
103 pub m_oldHandleRotation: Quaternion,
104 #[cfg_attr(feature = "json_schema", schemars(rename = "timeSinceLastModify"))]
110 #[cfg_attr(feature = "serde", serde(rename = "timeSinceLastModify"))]
111 pub m_timeSinceLastModify: f32,
112 #[cfg_attr(feature = "json_schema", schemars(rename = "smoothlyChangingHandles"))]
118 #[cfg_attr(feature = "serde", serde(rename = "smoothlyChangingHandles"))]
119 pub m_smoothlyChangingHandles: bool,
120}
121const _: () = {
122 use havok_serde as _serde;
123 impl<'a> _serde::HavokClass for hkbEvaluateHandleModifier<'a> {
124 #[inline]
125 fn name(&self) -> &'static str {
126 "hkbEvaluateHandleModifier"
127 }
128 #[inline]
129 fn signature(&self) -> _serde::__private::Signature {
130 _serde::__private::Signature::new(0x79757102)
131 }
132 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
133 fn deps_indexes(&self) -> Vec<usize> {
134 let mut v = Vec::new();
135 v.push(self.parent.parent.parent.m_variableBindingSet.get());
136 v.push(self.m_handle.get());
137 v.extend(self.m_oldHandle.deps_indexes());
138 v
139 }
140 }
141 impl<'a> _serde::Serialize for hkbEvaluateHandleModifier<'a> {
142 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
143 where
144 S: _serde::ser::Serializer,
145 {
146 let class_meta = self
147 .__ptr
148 .map(|name| (name, _serde::__private::Signature::new(0x79757102)));
149 let mut serializer = __serializer
150 .serialize_struct(
151 "hkbEvaluateHandleModifier",
152 class_meta,
153 (176u64, 240u64),
154 )?;
155 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
156 serializer
157 .skip_field(
158 "memSizeAndFlags",
159 &self.parent.parent.parent.parent.m_memSizeAndFlags,
160 )?;
161 serializer
162 .skip_field(
163 "referenceCount",
164 &self.parent.parent.parent.parent.m_referenceCount,
165 )?;
166 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
167 serializer
168 .serialize_field(
169 "variableBindingSet",
170 &self.parent.parent.parent.m_variableBindingSet,
171 )?;
172 serializer
173 .skip_array_field(
174 "cachedBindables",
175 &self.parent.parent.parent.m_cachedBindables,
176 TypeSize::NonPtr,
177 )?;
178 serializer
179 .skip_field(
180 "areBindablesCached",
181 &self.parent.parent.parent.m_areBindablesCached,
182 )?;
183 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
184 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
185 serializer.serialize_field("name", &self.parent.parent.m_name)?;
186 serializer.skip_field("id", &self.parent.parent.m_id)?;
187 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
188 serializer
189 .skip_fixed_array_field(
190 "padNode",
191 self.parent.parent.m_padNode.as_slice(),
192 TypeSize::NonPtr,
193 )?;
194 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
195 serializer.serialize_field("enable", &self.parent.m_enable)?;
196 serializer
197 .skip_fixed_array_field(
198 "padModifier",
199 self.parent.m_padModifier.as_slice(),
200 TypeSize::NonPtr,
201 )?;
202 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
203 serializer.serialize_field("handle", &self.m_handle)?;
204 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 8usize].as_slice())?;
205 serializer.serialize_field("handlePositionOut", &self.m_handlePositionOut)?;
206 serializer.serialize_field("handleRotationOut", &self.m_handleRotationOut)?;
207 serializer.serialize_field("isValidOut", &self.m_isValidOut)?;
208 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
209 serializer
210 .serialize_field(
211 "extrapolationTimeStep",
212 &self.m_extrapolationTimeStep,
213 )?;
214 serializer.serialize_field("handleChangeSpeed", &self.m_handleChangeSpeed)?;
215 serializer.serialize_field("handleChangeMode", &self.m_handleChangeMode)?;
216 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
217 serializer.skip_field("oldHandle", &self.m_oldHandle)?;
218 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
219 serializer.skip_field("oldHandlePosition", &self.m_oldHandlePosition)?;
220 serializer.skip_field("oldHandleRotation", &self.m_oldHandleRotation)?;
221 serializer.skip_field("timeSinceLastModify", &self.m_timeSinceLastModify)?;
222 serializer
223 .skip_field("smoothlyChangingHandles", &self.m_smoothlyChangingHandles)?;
224 serializer.pad_field([0u8; 11usize].as_slice(), [0u8; 11usize].as_slice())?;
225 serializer.end()
226 }
227 }
228};
229#[doc(hidden)]
230#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
231const _: () = {
232 use havok_serde as _serde;
233 #[automatically_derived]
234 impl<'de> _serde::Deserialize<'de> for hkbEvaluateHandleModifier<'de> {
235 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
236 where
237 __D: _serde::Deserializer<'de>,
238 {
239 #[allow(non_camel_case_types)]
240 enum __Field {
241 m_variableBindingSet,
242 m_userData,
243 m_name,
244 m_enable,
245 m_handle,
246 m_handlePositionOut,
247 m_handleRotationOut,
248 m_isValidOut,
249 m_extrapolationTimeStep,
250 m_handleChangeSpeed,
251 m_handleChangeMode,
252 __ignore,
253 }
254 struct __FieldVisitor;
255 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
256 type Value = __Field;
257 fn expecting(
258 &self,
259 __formatter: &mut core::fmt::Formatter,
260 ) -> core::fmt::Result {
261 core::fmt::Formatter::write_str(__formatter, "field identifier")
262 }
263 #[allow(clippy::match_single_binding)]
265 #[allow(clippy::reversed_empty_ranges)]
266 #[allow(clippy::single_match)]
267 fn visit_key<__E>(
268 self,
269 __value: &str,
270 ) -> core::result::Result<Self::Value, __E>
271 where
272 __E: _serde::de::Error,
273 {
274 match __value {
275 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
276 "userData" => Ok(__Field::m_userData),
277 "name" => Ok(__Field::m_name),
278 "enable" => Ok(__Field::m_enable),
279 "handle" => Ok(__Field::m_handle),
280 "handlePositionOut" => Ok(__Field::m_handlePositionOut),
281 "handleRotationOut" => Ok(__Field::m_handleRotationOut),
282 "isValidOut" => Ok(__Field::m_isValidOut),
283 "extrapolationTimeStep" => Ok(__Field::m_extrapolationTimeStep),
284 "handleChangeSpeed" => Ok(__Field::m_handleChangeSpeed),
285 "handleChangeMode" => Ok(__Field::m_handleChangeMode),
286 _ => Ok(__Field::__ignore),
287 }
288 }
289 }
290 impl<'de> _serde::Deserialize<'de> for __Field {
291 #[inline]
292 fn deserialize<__D>(
293 __deserializer: __D,
294 ) -> core::result::Result<Self, __D::Error>
295 where
296 __D: _serde::Deserializer<'de>,
297 {
298 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
299 }
300 }
301 struct __hkbEvaluateHandleModifierVisitor<'de> {
302 marker: _serde::__private::PhantomData<hkbEvaluateHandleModifier<'de>>,
303 lifetime: _serde::__private::PhantomData<&'de ()>,
304 }
305 #[allow(clippy::match_single_binding)]
306 #[allow(clippy::reversed_empty_ranges)]
307 #[allow(clippy::single_match)]
308 impl<'de> _serde::de::Visitor<'de>
309 for __hkbEvaluateHandleModifierVisitor<'de> {
310 type Value = hkbEvaluateHandleModifier<'de>;
311 fn expecting(
312 &self,
313 __formatter: &mut core::fmt::Formatter,
314 ) -> core::fmt::Result {
315 core::fmt::Formatter::write_str(
316 __formatter,
317 "struct hkbEvaluateHandleModifier",
318 )
319 }
320 fn visit_struct_for_bytes<__A>(
321 self,
322 mut __map: __A,
323 ) -> _serde::__private::Result<Self::Value, __A::Error>
324 where
325 __A: _serde::de::MapAccess<'de>,
326 {
327 let __ptr = __A::class_ptr(&mut __map);
328 let parent = __A::parent_value(&mut __map)?;
329 let mut m_handle: _serde::__private::Option<Pointer> = _serde::__private::None;
330 let mut m_handlePositionOut: _serde::__private::Option<Vector4> = _serde::__private::None;
331 let mut m_handleRotationOut: _serde::__private::Option<Quaternion> = _serde::__private::None;
332 let mut m_isValidOut: _serde::__private::Option<bool> = _serde::__private::None;
333 let mut m_extrapolationTimeStep: _serde::__private::Option<f32> = _serde::__private::None;
334 let mut m_handleChangeSpeed: _serde::__private::Option<f32> = _serde::__private::None;
335 let mut m_handleChangeMode: _serde::__private::Option<
336 HandleChangeMode,
337 > = _serde::__private::None;
338 let mut m_oldHandle: _serde::__private::Option<hkbHandle> = _serde::__private::None;
339 let mut m_oldHandlePosition: _serde::__private::Option<Vector4> = _serde::__private::None;
340 let mut m_oldHandleRotation: _serde::__private::Option<Quaternion> = _serde::__private::None;
341 let mut m_timeSinceLastModify: _serde::__private::Option<f32> = _serde::__private::None;
342 let mut m_smoothlyChangingHandles: _serde::__private::Option<bool> = _serde::__private::None;
343 for i in 0..12usize {
344 match i {
345 0usize => {
346 if _serde::__private::Option::is_some(&m_handle) {
347 return _serde::__private::Err(
348 <__A::Error as _serde::de::Error>::duplicate_field("handle"),
349 );
350 }
351 m_handle = _serde::__private::Some(
352 match __A::next_value::<Pointer>(&mut __map) {
353 _serde::__private::Ok(__val) => __val,
354 _serde::__private::Err(__err) => {
355 return _serde::__private::Err(__err);
356 }
357 },
358 );
359 }
360 1usize => {
361 if _serde::__private::Option::is_some(
362 &m_handlePositionOut,
363 ) {
364 return _serde::__private::Err(
365 <__A::Error as _serde::de::Error>::duplicate_field(
366 "handlePositionOut",
367 ),
368 );
369 }
370 __A::pad(&mut __map, 0usize, 8usize)?;
371 m_handlePositionOut = _serde::__private::Some(
372 match __A::next_value::<Vector4>(&mut __map) {
373 _serde::__private::Ok(__val) => __val,
374 _serde::__private::Err(__err) => {
375 return _serde::__private::Err(__err);
376 }
377 },
378 );
379 }
380 2usize => {
381 if _serde::__private::Option::is_some(
382 &m_handleRotationOut,
383 ) {
384 return _serde::__private::Err(
385 <__A::Error as _serde::de::Error>::duplicate_field(
386 "handleRotationOut",
387 ),
388 );
389 }
390 m_handleRotationOut = _serde::__private::Some(
391 match __A::next_value::<Quaternion>(&mut __map) {
392 _serde::__private::Ok(__val) => __val,
393 _serde::__private::Err(__err) => {
394 return _serde::__private::Err(__err);
395 }
396 },
397 );
398 }
399 3usize => {
400 if _serde::__private::Option::is_some(&m_isValidOut) {
401 return _serde::__private::Err(
402 <__A::Error as _serde::de::Error>::duplicate_field(
403 "isValidOut",
404 ),
405 );
406 }
407 m_isValidOut = _serde::__private::Some(
408 match __A::next_value::<bool>(&mut __map) {
409 _serde::__private::Ok(__val) => __val,
410 _serde::__private::Err(__err) => {
411 return _serde::__private::Err(__err);
412 }
413 },
414 );
415 }
416 4usize => {
417 if _serde::__private::Option::is_some(
418 &m_extrapolationTimeStep,
419 ) {
420 return _serde::__private::Err(
421 <__A::Error as _serde::de::Error>::duplicate_field(
422 "extrapolationTimeStep",
423 ),
424 );
425 }
426 __A::pad(&mut __map, 3usize, 3usize)?;
427 m_extrapolationTimeStep = _serde::__private::Some(
428 match __A::next_value::<f32>(&mut __map) {
429 _serde::__private::Ok(__val) => __val,
430 _serde::__private::Err(__err) => {
431 return _serde::__private::Err(__err);
432 }
433 },
434 );
435 }
436 5usize => {
437 if _serde::__private::Option::is_some(
438 &m_handleChangeSpeed,
439 ) {
440 return _serde::__private::Err(
441 <__A::Error as _serde::de::Error>::duplicate_field(
442 "handleChangeSpeed",
443 ),
444 );
445 }
446 m_handleChangeSpeed = _serde::__private::Some(
447 match __A::next_value::<f32>(&mut __map) {
448 _serde::__private::Ok(__val) => __val,
449 _serde::__private::Err(__err) => {
450 return _serde::__private::Err(__err);
451 }
452 },
453 );
454 }
455 6usize => {
456 if _serde::__private::Option::is_some(&m_handleChangeMode) {
457 return _serde::__private::Err(
458 <__A::Error as _serde::de::Error>::duplicate_field(
459 "handleChangeMode",
460 ),
461 );
462 }
463 m_handleChangeMode = _serde::__private::Some(
464 match __A::next_value::<HandleChangeMode>(&mut __map) {
465 _serde::__private::Ok(__val) => __val,
466 _serde::__private::Err(__err) => {
467 return _serde::__private::Err(__err);
468 }
469 },
470 );
471 }
472 7usize => {
473 if _serde::__private::Option::is_some(&m_oldHandle) {
474 return _serde::__private::Err(
475 <__A::Error as _serde::de::Error>::duplicate_field(
476 "oldHandle",
477 ),
478 );
479 }
480 __A::pad(&mut __map, 3usize, 3usize)?;
481 m_oldHandle = _serde::__private::Some(
482 match __A::next_value::<hkbHandle>(&mut __map) {
483 _serde::__private::Ok(__val) => __val,
484 _serde::__private::Err(__err) => {
485 return _serde::__private::Err(__err);
486 }
487 },
488 );
489 }
490 8usize => {
491 if _serde::__private::Option::is_some(
492 &m_oldHandlePosition,
493 ) {
494 return _serde::__private::Err(
495 <__A::Error as _serde::de::Error>::duplicate_field(
496 "oldHandlePosition",
497 ),
498 );
499 }
500 __A::pad(&mut __map, 8usize, 0usize)?;
501 m_oldHandlePosition = _serde::__private::Some(
502 match __A::next_value::<Vector4>(&mut __map) {
503 _serde::__private::Ok(__val) => __val,
504 _serde::__private::Err(__err) => {
505 return _serde::__private::Err(__err);
506 }
507 },
508 );
509 }
510 9usize => {
511 if _serde::__private::Option::is_some(
512 &m_oldHandleRotation,
513 ) {
514 return _serde::__private::Err(
515 <__A::Error as _serde::de::Error>::duplicate_field(
516 "oldHandleRotation",
517 ),
518 );
519 }
520 m_oldHandleRotation = _serde::__private::Some(
521 match __A::next_value::<Quaternion>(&mut __map) {
522 _serde::__private::Ok(__val) => __val,
523 _serde::__private::Err(__err) => {
524 return _serde::__private::Err(__err);
525 }
526 },
527 );
528 }
529 10usize => {
530 if _serde::__private::Option::is_some(
531 &m_timeSinceLastModify,
532 ) {
533 return _serde::__private::Err(
534 <__A::Error as _serde::de::Error>::duplicate_field(
535 "timeSinceLastModify",
536 ),
537 );
538 }
539 m_timeSinceLastModify = _serde::__private::Some(
540 match __A::next_value::<f32>(&mut __map) {
541 _serde::__private::Ok(__val) => __val,
542 _serde::__private::Err(__err) => {
543 return _serde::__private::Err(__err);
544 }
545 },
546 );
547 }
548 11usize => {
549 if _serde::__private::Option::is_some(
550 &m_smoothlyChangingHandles,
551 ) {
552 return _serde::__private::Err(
553 <__A::Error as _serde::de::Error>::duplicate_field(
554 "smoothlyChangingHandles",
555 ),
556 );
557 }
558 m_smoothlyChangingHandles = _serde::__private::Some(
559 match __A::next_value::<bool>(&mut __map) {
560 _serde::__private::Ok(__val) => __val,
561 _serde::__private::Err(__err) => {
562 return _serde::__private::Err(__err);
563 }
564 },
565 );
566 }
567 _ => {}
568 }
569 }
570 __A::pad(&mut __map, 11usize, 11usize)?;
571 let m_handle = match m_handle {
572 _serde::__private::Some(__field) => __field,
573 _serde::__private::None => {
574 return _serde::__private::Err(
575 <__A::Error as _serde::de::Error>::missing_field("handle"),
576 );
577 }
578 };
579 let m_handlePositionOut = match m_handlePositionOut {
580 _serde::__private::Some(__field) => __field,
581 _serde::__private::None => {
582 return _serde::__private::Err(
583 <__A::Error as _serde::de::Error>::missing_field(
584 "handlePositionOut",
585 ),
586 );
587 }
588 };
589 let m_handleRotationOut = match m_handleRotationOut {
590 _serde::__private::Some(__field) => __field,
591 _serde::__private::None => {
592 return _serde::__private::Err(
593 <__A::Error as _serde::de::Error>::missing_field(
594 "handleRotationOut",
595 ),
596 );
597 }
598 };
599 let m_isValidOut = match m_isValidOut {
600 _serde::__private::Some(__field) => __field,
601 _serde::__private::None => {
602 return _serde::__private::Err(
603 <__A::Error as _serde::de::Error>::missing_field(
604 "isValidOut",
605 ),
606 );
607 }
608 };
609 let m_extrapolationTimeStep = match m_extrapolationTimeStep {
610 _serde::__private::Some(__field) => __field,
611 _serde::__private::None => {
612 return _serde::__private::Err(
613 <__A::Error as _serde::de::Error>::missing_field(
614 "extrapolationTimeStep",
615 ),
616 );
617 }
618 };
619 let m_handleChangeSpeed = match m_handleChangeSpeed {
620 _serde::__private::Some(__field) => __field,
621 _serde::__private::None => {
622 return _serde::__private::Err(
623 <__A::Error as _serde::de::Error>::missing_field(
624 "handleChangeSpeed",
625 ),
626 );
627 }
628 };
629 let m_handleChangeMode = match m_handleChangeMode {
630 _serde::__private::Some(__field) => __field,
631 _serde::__private::None => {
632 return _serde::__private::Err(
633 <__A::Error as _serde::de::Error>::missing_field(
634 "handleChangeMode",
635 ),
636 );
637 }
638 };
639 let m_oldHandle = match m_oldHandle {
640 _serde::__private::Some(__field) => __field,
641 _serde::__private::None => {
642 return _serde::__private::Err(
643 <__A::Error as _serde::de::Error>::missing_field(
644 "oldHandle",
645 ),
646 );
647 }
648 };
649 let m_oldHandlePosition = match m_oldHandlePosition {
650 _serde::__private::Some(__field) => __field,
651 _serde::__private::None => {
652 return _serde::__private::Err(
653 <__A::Error as _serde::de::Error>::missing_field(
654 "oldHandlePosition",
655 ),
656 );
657 }
658 };
659 let m_oldHandleRotation = match m_oldHandleRotation {
660 _serde::__private::Some(__field) => __field,
661 _serde::__private::None => {
662 return _serde::__private::Err(
663 <__A::Error as _serde::de::Error>::missing_field(
664 "oldHandleRotation",
665 ),
666 );
667 }
668 };
669 let m_timeSinceLastModify = match m_timeSinceLastModify {
670 _serde::__private::Some(__field) => __field,
671 _serde::__private::None => {
672 return _serde::__private::Err(
673 <__A::Error as _serde::de::Error>::missing_field(
674 "timeSinceLastModify",
675 ),
676 );
677 }
678 };
679 let m_smoothlyChangingHandles = match m_smoothlyChangingHandles {
680 _serde::__private::Some(__field) => __field,
681 _serde::__private::None => {
682 return _serde::__private::Err(
683 <__A::Error as _serde::de::Error>::missing_field(
684 "smoothlyChangingHandles",
685 ),
686 );
687 }
688 };
689 _serde::__private::Ok(hkbEvaluateHandleModifier {
690 __ptr,
691 parent,
692 m_handle,
693 m_handlePositionOut,
694 m_handleRotationOut,
695 m_isValidOut,
696 m_extrapolationTimeStep,
697 m_handleChangeSpeed,
698 m_handleChangeMode,
699 m_oldHandle,
700 m_oldHandlePosition,
701 m_oldHandleRotation,
702 m_timeSinceLastModify,
703 m_smoothlyChangingHandles,
704 })
705 }
706 #[allow(clippy::manual_unwrap_or_default)]
707 fn visit_struct<__A>(
708 self,
709 mut __map: __A,
710 ) -> _serde::__private::Result<Self::Value, __A::Error>
711 where
712 __A: _serde::de::MapAccess<'de>,
713 {
714 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
715 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
716 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
717 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
718 let mut m_handle: _serde::__private::Option<Pointer> = _serde::__private::None;
719 let mut m_handlePositionOut: _serde::__private::Option<Vector4> = _serde::__private::None;
720 let mut m_handleRotationOut: _serde::__private::Option<Quaternion> = _serde::__private::None;
721 let mut m_isValidOut: _serde::__private::Option<bool> = _serde::__private::None;
722 let mut m_extrapolationTimeStep: _serde::__private::Option<f32> = _serde::__private::None;
723 let mut m_handleChangeSpeed: _serde::__private::Option<f32> = _serde::__private::None;
724 let mut m_handleChangeMode: _serde::__private::Option<
725 HandleChangeMode,
726 > = _serde::__private::None;
727 while let _serde::__private::Some(__key) = {
728 __A::next_key::<__Field>(&mut __map)?
729 } {
730 match __key {
731 __Field::m_variableBindingSet => {
732 #[cfg(
733 any(feature = "strict", feature = "ignore_duplicates")
734 )]
735 if _serde::__private::Option::is_some(
736 &m_variableBindingSet,
737 ) {
738 #[cfg(feature = "ignore_duplicates")]
739 {
740 __A::skip_value(&mut __map)?;
741 continue;
742 }
743 #[cfg(feature = "strict")]
744 return _serde::__private::Err(
745 <__A::Error as _serde::de::Error>::duplicate_field(
746 "variableBindingSet",
747 ),
748 );
749 }
750 m_variableBindingSet = _serde::__private::Some(
751 match __A::next_value::<Pointer>(&mut __map) {
752 _serde::__private::Ok(__val) => __val,
753 _serde::__private::Err(__err) => {
754 return _serde::__private::Err(__err);
755 }
756 },
757 );
758 }
759 __Field::m_userData => {
760 #[cfg(
761 any(feature = "strict", feature = "ignore_duplicates")
762 )]
763 if _serde::__private::Option::is_some(&m_userData) {
764 #[cfg(feature = "ignore_duplicates")]
765 {
766 __A::skip_value(&mut __map)?;
767 continue;
768 }
769 #[cfg(feature = "strict")]
770 return _serde::__private::Err(
771 <__A::Error as _serde::de::Error>::duplicate_field(
772 "userData",
773 ),
774 );
775 }
776 m_userData = _serde::__private::Some(
777 match __A::next_value::<Ulong>(&mut __map) {
778 _serde::__private::Ok(__val) => __val,
779 _serde::__private::Err(__err) => {
780 return _serde::__private::Err(__err);
781 }
782 },
783 );
784 }
785 __Field::m_name => {
786 #[cfg(
787 any(feature = "strict", feature = "ignore_duplicates")
788 )]
789 if _serde::__private::Option::is_some(&m_name) {
790 #[cfg(feature = "ignore_duplicates")]
791 {
792 __A::skip_value(&mut __map)?;
793 continue;
794 }
795 #[cfg(feature = "strict")]
796 return _serde::__private::Err(
797 <__A::Error as _serde::de::Error>::duplicate_field("name"),
798 );
799 }
800 m_name = _serde::__private::Some(
801 match __A::next_value::<StringPtr<'de>>(&mut __map) {
802 _serde::__private::Ok(__val) => __val,
803 _serde::__private::Err(__err) => {
804 return _serde::__private::Err(__err);
805 }
806 },
807 );
808 }
809 __Field::m_enable => {
810 #[cfg(
811 any(feature = "strict", feature = "ignore_duplicates")
812 )]
813 if _serde::__private::Option::is_some(&m_enable) {
814 #[cfg(feature = "ignore_duplicates")]
815 {
816 __A::skip_value(&mut __map)?;
817 continue;
818 }
819 #[cfg(feature = "strict")]
820 return _serde::__private::Err(
821 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
822 );
823 }
824 m_enable = _serde::__private::Some(
825 match __A::next_value::<bool>(&mut __map) {
826 _serde::__private::Ok(__val) => __val,
827 _serde::__private::Err(__err) => {
828 return _serde::__private::Err(__err);
829 }
830 },
831 );
832 }
833 __Field::m_handle => {
834 #[cfg(
835 any(feature = "strict", feature = "ignore_duplicates")
836 )]
837 if _serde::__private::Option::is_some(&m_handle) {
838 #[cfg(feature = "ignore_duplicates")]
839 {
840 __A::skip_value(&mut __map)?;
841 continue;
842 }
843 #[cfg(feature = "strict")]
844 return _serde::__private::Err(
845 <__A::Error as _serde::de::Error>::duplicate_field("handle"),
846 );
847 }
848 m_handle = _serde::__private::Some(
849 match __A::next_value::<Pointer>(&mut __map) {
850 _serde::__private::Ok(__val) => __val,
851 _serde::__private::Err(__err) => {
852 return _serde::__private::Err(__err);
853 }
854 },
855 );
856 }
857 __Field::m_handlePositionOut => {
858 #[cfg(
859 any(feature = "strict", feature = "ignore_duplicates")
860 )]
861 if _serde::__private::Option::is_some(
862 &m_handlePositionOut,
863 ) {
864 #[cfg(feature = "ignore_duplicates")]
865 {
866 __A::skip_value(&mut __map)?;
867 continue;
868 }
869 #[cfg(feature = "strict")]
870 return _serde::__private::Err(
871 <__A::Error as _serde::de::Error>::duplicate_field(
872 "handlePositionOut",
873 ),
874 );
875 }
876 m_handlePositionOut = _serde::__private::Some(
877 match __A::next_value::<Vector4>(&mut __map) {
878 _serde::__private::Ok(__val) => __val,
879 _serde::__private::Err(__err) => {
880 return _serde::__private::Err(__err);
881 }
882 },
883 );
884 }
885 __Field::m_handleRotationOut => {
886 #[cfg(
887 any(feature = "strict", feature = "ignore_duplicates")
888 )]
889 if _serde::__private::Option::is_some(
890 &m_handleRotationOut,
891 ) {
892 #[cfg(feature = "ignore_duplicates")]
893 {
894 __A::skip_value(&mut __map)?;
895 continue;
896 }
897 #[cfg(feature = "strict")]
898 return _serde::__private::Err(
899 <__A::Error as _serde::de::Error>::duplicate_field(
900 "handleRotationOut",
901 ),
902 );
903 }
904 m_handleRotationOut = _serde::__private::Some(
905 match __A::next_value::<Quaternion>(&mut __map) {
906 _serde::__private::Ok(__val) => __val,
907 _serde::__private::Err(__err) => {
908 return _serde::__private::Err(__err);
909 }
910 },
911 );
912 }
913 __Field::m_isValidOut => {
914 #[cfg(
915 any(feature = "strict", feature = "ignore_duplicates")
916 )]
917 if _serde::__private::Option::is_some(&m_isValidOut) {
918 #[cfg(feature = "ignore_duplicates")]
919 {
920 __A::skip_value(&mut __map)?;
921 continue;
922 }
923 #[cfg(feature = "strict")]
924 return _serde::__private::Err(
925 <__A::Error as _serde::de::Error>::duplicate_field(
926 "isValidOut",
927 ),
928 );
929 }
930 m_isValidOut = _serde::__private::Some(
931 match __A::next_value::<bool>(&mut __map) {
932 _serde::__private::Ok(__val) => __val,
933 _serde::__private::Err(__err) => {
934 return _serde::__private::Err(__err);
935 }
936 },
937 );
938 }
939 __Field::m_extrapolationTimeStep => {
940 #[cfg(
941 any(feature = "strict", feature = "ignore_duplicates")
942 )]
943 if _serde::__private::Option::is_some(
944 &m_extrapolationTimeStep,
945 ) {
946 #[cfg(feature = "ignore_duplicates")]
947 {
948 __A::skip_value(&mut __map)?;
949 continue;
950 }
951 #[cfg(feature = "strict")]
952 return _serde::__private::Err(
953 <__A::Error as _serde::de::Error>::duplicate_field(
954 "extrapolationTimeStep",
955 ),
956 );
957 }
958 m_extrapolationTimeStep = _serde::__private::Some(
959 match __A::next_value::<f32>(&mut __map) {
960 _serde::__private::Ok(__val) => __val,
961 _serde::__private::Err(__err) => {
962 return _serde::__private::Err(__err);
963 }
964 },
965 );
966 }
967 __Field::m_handleChangeSpeed => {
968 #[cfg(
969 any(feature = "strict", feature = "ignore_duplicates")
970 )]
971 if _serde::__private::Option::is_some(
972 &m_handleChangeSpeed,
973 ) {
974 #[cfg(feature = "ignore_duplicates")]
975 {
976 __A::skip_value(&mut __map)?;
977 continue;
978 }
979 #[cfg(feature = "strict")]
980 return _serde::__private::Err(
981 <__A::Error as _serde::de::Error>::duplicate_field(
982 "handleChangeSpeed",
983 ),
984 );
985 }
986 m_handleChangeSpeed = _serde::__private::Some(
987 match __A::next_value::<f32>(&mut __map) {
988 _serde::__private::Ok(__val) => __val,
989 _serde::__private::Err(__err) => {
990 return _serde::__private::Err(__err);
991 }
992 },
993 );
994 }
995 __Field::m_handleChangeMode => {
996 #[cfg(
997 any(feature = "strict", feature = "ignore_duplicates")
998 )]
999 if _serde::__private::Option::is_some(&m_handleChangeMode) {
1000 #[cfg(feature = "ignore_duplicates")]
1001 {
1002 __A::skip_value(&mut __map)?;
1003 continue;
1004 }
1005 #[cfg(feature = "strict")]
1006 return _serde::__private::Err(
1007 <__A::Error as _serde::de::Error>::duplicate_field(
1008 "handleChangeMode",
1009 ),
1010 );
1011 }
1012 m_handleChangeMode = _serde::__private::Some(
1013 match __A::next_value::<HandleChangeMode>(&mut __map) {
1014 _serde::__private::Ok(__val) => __val,
1015 _serde::__private::Err(__err) => {
1016 return _serde::__private::Err(__err);
1017 }
1018 },
1019 );
1020 }
1021 _ => __A::skip_value(&mut __map)?,
1022 }
1023 }
1024 let m_variableBindingSet = match m_variableBindingSet {
1025 _serde::__private::Some(__field) => __field,
1026 _serde::__private::None => {
1027 #[cfg(feature = "strict")]
1028 return _serde::__private::Err(
1029 <__A::Error as _serde::de::Error>::missing_field(
1030 "variableBindingSet",
1031 ),
1032 );
1033 #[cfg(not(feature = "strict"))] Default::default()
1034 }
1035 };
1036 let m_userData = match m_userData {
1037 _serde::__private::Some(__field) => __field,
1038 _serde::__private::None => {
1039 #[cfg(feature = "strict")]
1040 return _serde::__private::Err(
1041 <__A::Error as _serde::de::Error>::missing_field("userData"),
1042 );
1043 #[cfg(not(feature = "strict"))] Default::default()
1044 }
1045 };
1046 let m_name = match m_name {
1047 _serde::__private::Some(__field) => __field,
1048 _serde::__private::None => {
1049 #[cfg(feature = "strict")]
1050 return _serde::__private::Err(
1051 <__A::Error as _serde::de::Error>::missing_field("name"),
1052 );
1053 #[cfg(not(feature = "strict"))] Default::default()
1054 }
1055 };
1056 let m_enable = match m_enable {
1057 _serde::__private::Some(__field) => __field,
1058 _serde::__private::None => {
1059 #[cfg(feature = "strict")]
1060 return _serde::__private::Err(
1061 <__A::Error as _serde::de::Error>::missing_field("enable"),
1062 );
1063 #[cfg(not(feature = "strict"))] Default::default()
1064 }
1065 };
1066 let m_handle = match m_handle {
1067 _serde::__private::Some(__field) => __field,
1068 _serde::__private::None => {
1069 #[cfg(feature = "strict")]
1070 return _serde::__private::Err(
1071 <__A::Error as _serde::de::Error>::missing_field("handle"),
1072 );
1073 #[cfg(not(feature = "strict"))] Default::default()
1074 }
1075 };
1076 let m_handlePositionOut = match m_handlePositionOut {
1077 _serde::__private::Some(__field) => __field,
1078 _serde::__private::None => {
1079 #[cfg(feature = "strict")]
1080 return _serde::__private::Err(
1081 <__A::Error as _serde::de::Error>::missing_field(
1082 "handlePositionOut",
1083 ),
1084 );
1085 #[cfg(not(feature = "strict"))] Default::default()
1086 }
1087 };
1088 let m_handleRotationOut = match m_handleRotationOut {
1089 _serde::__private::Some(__field) => __field,
1090 _serde::__private::None => {
1091 #[cfg(feature = "strict")]
1092 return _serde::__private::Err(
1093 <__A::Error as _serde::de::Error>::missing_field(
1094 "handleRotationOut",
1095 ),
1096 );
1097 #[cfg(not(feature = "strict"))] Default::default()
1098 }
1099 };
1100 let m_isValidOut = match m_isValidOut {
1101 _serde::__private::Some(__field) => __field,
1102 _serde::__private::None => {
1103 #[cfg(feature = "strict")]
1104 return _serde::__private::Err(
1105 <__A::Error as _serde::de::Error>::missing_field(
1106 "isValidOut",
1107 ),
1108 );
1109 #[cfg(not(feature = "strict"))] Default::default()
1110 }
1111 };
1112 let m_extrapolationTimeStep = match m_extrapolationTimeStep {
1113 _serde::__private::Some(__field) => __field,
1114 _serde::__private::None => {
1115 #[cfg(feature = "strict")]
1116 return _serde::__private::Err(
1117 <__A::Error as _serde::de::Error>::missing_field(
1118 "extrapolationTimeStep",
1119 ),
1120 );
1121 #[cfg(not(feature = "strict"))] Default::default()
1122 }
1123 };
1124 let m_handleChangeSpeed = match m_handleChangeSpeed {
1125 _serde::__private::Some(__field) => __field,
1126 _serde::__private::None => {
1127 #[cfg(feature = "strict")]
1128 return _serde::__private::Err(
1129 <__A::Error as _serde::de::Error>::missing_field(
1130 "handleChangeSpeed",
1131 ),
1132 );
1133 #[cfg(not(feature = "strict"))] Default::default()
1134 }
1135 };
1136 let m_handleChangeMode = match m_handleChangeMode {
1137 _serde::__private::Some(__field) => __field,
1138 _serde::__private::None => {
1139 #[cfg(feature = "strict")]
1140 return _serde::__private::Err(
1141 <__A::Error as _serde::de::Error>::missing_field(
1142 "handleChangeMode",
1143 ),
1144 );
1145 #[cfg(not(feature = "strict"))] Default::default()
1146 }
1147 };
1148 let __ptr = None;
1149 let parent = hkBaseObject { __ptr };
1150 let parent = hkReferencedObject {
1151 __ptr,
1152 parent,
1153 ..Default::default()
1154 };
1155 let parent = hkbBindable {
1156 __ptr,
1157 parent,
1158 m_variableBindingSet,
1159 ..Default::default()
1160 };
1161 let parent = hkbNode {
1162 __ptr,
1163 parent,
1164 m_userData,
1165 m_name,
1166 ..Default::default()
1167 };
1168 let parent = hkbModifier {
1169 __ptr,
1170 parent,
1171 m_enable,
1172 ..Default::default()
1173 };
1174 let __ptr = __A::class_ptr(&mut __map);
1175 _serde::__private::Ok(hkbEvaluateHandleModifier {
1176 __ptr,
1177 parent,
1178 m_handle,
1179 m_handlePositionOut,
1180 m_handleRotationOut,
1181 m_isValidOut,
1182 m_extrapolationTimeStep,
1183 m_handleChangeSpeed,
1184 m_handleChangeMode,
1185 ..Default::default()
1186 })
1187 }
1188 }
1189 const FIELDS: &[&str] = &[
1190 "handle",
1191 "handlePositionOut",
1192 "handleRotationOut",
1193 "isValidOut",
1194 "extrapolationTimeStep",
1195 "handleChangeSpeed",
1196 "handleChangeMode",
1197 "oldHandle",
1198 "oldHandlePosition",
1199 "oldHandleRotation",
1200 "timeSinceLastModify",
1201 "smoothlyChangingHandles",
1202 ];
1203 _serde::Deserializer::deserialize_struct(
1204 deserializer,
1205 "hkbEvaluateHandleModifier",
1206 FIELDS,
1207 __hkbEvaluateHandleModifierVisitor {
1208 marker: _serde::__private::PhantomData::<hkbEvaluateHandleModifier>,
1209 lifetime: _serde::__private::PhantomData,
1210 },
1211 )
1212 }
1213 }
1214};
1215#[allow(non_upper_case_globals, non_snake_case)]
1218#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1219#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1220#[derive(
1221 Debug,
1222 Clone,
1223 Default,
1224 PartialEq,
1225 Eq,
1226 PartialOrd,
1227 Ord,
1228 num_derive::ToPrimitive,
1229 num_derive::FromPrimitive,
1230)]
1231pub enum HandleChangeMode {
1232 #[default]
1233 HANDLE_CHANGE_MODE_ABRUPT = 0isize,
1234 HANDLE_CHANGE_MODE_CONSTANT_VELOCITY = 1isize,
1235}
1236const _: () = {
1237 use havok_serde as __serde;
1238 impl __serde::Serialize for HandleChangeMode {
1239 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1240 where
1241 S: __serde::ser::Serializer,
1242 {
1243 let mut __serializer = __serializer.serialize_enum_flags()?;
1244 match self {
1245 Self::HANDLE_CHANGE_MODE_ABRUPT => {
1246 __serializer.serialize_field("HANDLE_CHANGE_MODE_ABRUPT", &0u64)
1247 }
1248 Self::HANDLE_CHANGE_MODE_CONSTANT_VELOCITY => {
1249 __serializer
1250 .serialize_field("HANDLE_CHANGE_MODE_CONSTANT_VELOCITY", &1u64)
1251 }
1252 }?;
1253 use num_traits::ToPrimitive as _;
1254 let num = self
1255 .to_i8()
1256 .ok_or(S::Error::custom("Failed enum HandleChangeMode to_i8"))?;
1257 __serializer.serialize_bits(&num)?;
1258 __serializer.end()
1259 }
1260 }
1261};
1262#[doc(hidden)]
1263#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1264const _: () = {
1265 #[allow(unused_extern_crates, clippy::useless_attribute)]
1266 extern crate havok_serde as _serde;
1267 #[automatically_derived]
1268 impl<'de> _serde::Deserialize<'de> for HandleChangeMode {
1269 fn deserialize<__D>(
1270 __deserializer: __D,
1271 ) -> _serde::__private::Result<Self, __D::Error>
1272 where
1273 __D: _serde::Deserializer<'de>,
1274 {
1275 #[allow(non_camel_case_types)]
1276 #[doc(hidden)]
1277 enum __Field {
1278 __field0,
1279 __field1,
1280 }
1281 #[doc(hidden)]
1282 struct __FieldVisitor;
1283 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1284 type Value = __Field;
1285 fn expecting(
1286 &self,
1287 __formatter: &mut _serde::__private::Formatter,
1288 ) -> _serde::__private::fmt::Result {
1289 _serde::__private::Formatter::write_str(
1290 __formatter,
1291 "variant identifier",
1292 )
1293 }
1294 fn visit_int8<__E>(
1295 self,
1296 __value: i8,
1297 ) -> _serde::__private::Result<Self::Value, __E>
1298 where
1299 __E: _serde::de::Error,
1300 {
1301 match __value {
1302 0i8 => _serde::__private::Ok(__Field::__field0),
1303 1i8 => _serde::__private::Ok(__Field::__field1),
1304 _ => {
1305 _serde::__private::Err(
1306 _serde::de::Error::invalid_value(
1307 _serde::de::Unexpected::Int8(__value),
1308 &"value(i8) of variant is one of 0, 1",
1309 ),
1310 )
1311 }
1312 }
1313 }
1314 fn visit_stringptr<__E>(
1315 self,
1316 __value: StringPtr<'de>,
1317 ) -> _serde::__private::Result<Self::Value, __E>
1318 where
1319 __E: _serde::de::Error,
1320 {
1321 if let Some(__value) = __value.into_inner() {
1322 match __value.as_ref() {
1323 v if v == "0"
1324 || v.eq_ignore_ascii_case("HANDLE_CHANGE_MODE_ABRUPT") => {
1325 _serde::__private::Ok(__Field::__field0)
1326 }
1327 v if v == "1"
1328 || v
1329 .eq_ignore_ascii_case(
1330 "HANDLE_CHANGE_MODE_CONSTANT_VELOCITY",
1331 ) => _serde::__private::Ok(__Field::__field1),
1332 _ => {
1333 _serde::__private::Err(
1334 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1335 )
1336 }
1337 }
1338 } else {
1339 _serde::__private::Err(
1340 _serde::de::Error::unknown_variant("None", VARIANTS),
1341 )
1342 }
1343 }
1344 }
1345 impl<'de> _serde::Deserialize<'de> for __Field {
1346 #[inline]
1347 fn deserialize<__D>(
1348 __deserializer: __D,
1349 ) -> _serde::__private::Result<Self, __D::Error>
1350 where
1351 __D: _serde::Deserializer<'de>,
1352 {
1353 _serde::Deserializer::deserialize_identifier(
1354 __deserializer,
1355 _serde::de::ReadEnumSize::Int8,
1356 __FieldVisitor,
1357 )
1358 }
1359 }
1360 #[doc(hidden)]
1361 struct __Visitor<'de> {
1362 marker: _serde::__private::PhantomData<HandleChangeMode>,
1363 lifetime: _serde::__private::PhantomData<&'de ()>,
1364 }
1365 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1366 type Value = HandleChangeMode;
1367 fn expecting(
1368 &self,
1369 __formatter: &mut _serde::__private::Formatter,
1370 ) -> _serde::__private::fmt::Result {
1371 _serde::__private::Formatter::write_str(
1372 __formatter,
1373 "enum HandleChangeMode",
1374 )
1375 }
1376 fn visit_enum<__A>(
1377 self,
1378 __data: __A,
1379 ) -> _serde::__private::Result<Self::Value, __A::Error>
1380 where
1381 __A: _serde::de::EnumAccess<'de>,
1382 {
1383 match _serde::de::EnumAccess::variant(__data)? {
1384 (__Field::__field0, __variant) => {
1385 _serde::de::VariantAccess::unit_variant(__variant)?;
1386 _serde::__private::Ok(
1387 HandleChangeMode::HANDLE_CHANGE_MODE_ABRUPT,
1388 )
1389 }
1390 (__Field::__field1, __variant) => {
1391 _serde::de::VariantAccess::unit_variant(__variant)?;
1392 _serde::__private::Ok(
1393 HandleChangeMode::HANDLE_CHANGE_MODE_CONSTANT_VELOCITY,
1394 )
1395 }
1396 }
1397 }
1398 }
1399 #[doc(hidden)]
1400 const VARIANTS: &'static [&'static str] = &[
1401 "HANDLE_CHANGE_MODE_ABRUPT",
1402 "HANDLE_CHANGE_MODE_CONSTANT_VELOCITY",
1403 ];
1404 _serde::Deserializer::deserialize_enum(
1405 __deserializer,
1406 "HandleChangeMode",
1407 VARIANTS,
1408 __Visitor {
1409 marker: _serde::__private::PhantomData::<HandleChangeMode>,
1410 lifetime: _serde::__private::PhantomData,
1411 },
1412 )
1413 }
1414 }
1415};