1pub const SKIN_ENTRIES_HASH_TABLE_SIZE: u32 = 100;
4#[repr(C)]
5#[derive(Debug, Copy, Clone)]
6pub struct spEventData {
7 pub name: *const ::std::os::raw::c_char,
8 pub intValue: ::std::os::raw::c_int,
9 pub floatValue: f32,
10 pub stringValue: *const ::std::os::raw::c_char,
11 pub audioPath: *const ::std::os::raw::c_char,
12 pub volume: f32,
13 pub balance: f32,
14}
15#[test]
16fn bindgen_test_layout_spEventData() {
17 assert_eq!(
18 ::std::mem::size_of::<spEventData>(),
19 40usize,
20 concat!("Size of: ", stringify!(spEventData))
21 );
22 assert_eq!(
23 ::std::mem::align_of::<spEventData>(),
24 8usize,
25 concat!("Alignment of ", stringify!(spEventData))
26 );
27 assert_eq!(
28 unsafe { &(*(::std::ptr::null::<spEventData>())).name as *const _ as usize },
29 0usize,
30 concat!(
31 "Offset of field: ",
32 stringify!(spEventData),
33 "::",
34 stringify!(name)
35 )
36 );
37 assert_eq!(
38 unsafe { &(*(::std::ptr::null::<spEventData>())).intValue as *const _ as usize },
39 8usize,
40 concat!(
41 "Offset of field: ",
42 stringify!(spEventData),
43 "::",
44 stringify!(intValue)
45 )
46 );
47 assert_eq!(
48 unsafe { &(*(::std::ptr::null::<spEventData>())).floatValue as *const _ as usize },
49 12usize,
50 concat!(
51 "Offset of field: ",
52 stringify!(spEventData),
53 "::",
54 stringify!(floatValue)
55 )
56 );
57 assert_eq!(
58 unsafe { &(*(::std::ptr::null::<spEventData>())).stringValue as *const _ as usize },
59 16usize,
60 concat!(
61 "Offset of field: ",
62 stringify!(spEventData),
63 "::",
64 stringify!(stringValue)
65 )
66 );
67 assert_eq!(
68 unsafe { &(*(::std::ptr::null::<spEventData>())).audioPath as *const _ as usize },
69 24usize,
70 concat!(
71 "Offset of field: ",
72 stringify!(spEventData),
73 "::",
74 stringify!(audioPath)
75 )
76 );
77 assert_eq!(
78 unsafe { &(*(::std::ptr::null::<spEventData>())).volume as *const _ as usize },
79 32usize,
80 concat!(
81 "Offset of field: ",
82 stringify!(spEventData),
83 "::",
84 stringify!(volume)
85 )
86 );
87 assert_eq!(
88 unsafe { &(*(::std::ptr::null::<spEventData>())).balance as *const _ as usize },
89 36usize,
90 concat!(
91 "Offset of field: ",
92 stringify!(spEventData),
93 "::",
94 stringify!(balance)
95 )
96 );
97}
98extern "C" {
99 pub fn spEventData_create(name: *const ::std::os::raw::c_char) -> *mut spEventData;
100}
101extern "C" {
102 pub fn spEventData_dispose(self_: *mut spEventData);
103}
104#[repr(C)]
105#[derive(Debug, Copy, Clone)]
106pub struct spEvent {
107 pub data: *mut spEventData,
108 pub time: f32,
109 pub intValue: ::std::os::raw::c_int,
110 pub floatValue: f32,
111 pub stringValue: *const ::std::os::raw::c_char,
112 pub volume: f32,
113 pub balance: f32,
114}
115#[test]
116fn bindgen_test_layout_spEvent() {
117 assert_eq!(
118 ::std::mem::size_of::<spEvent>(),
119 40usize,
120 concat!("Size of: ", stringify!(spEvent))
121 );
122 assert_eq!(
123 ::std::mem::align_of::<spEvent>(),
124 8usize,
125 concat!("Alignment of ", stringify!(spEvent))
126 );
127 assert_eq!(
128 unsafe { &(*(::std::ptr::null::<spEvent>())).data as *const _ as usize },
129 0usize,
130 concat!(
131 "Offset of field: ",
132 stringify!(spEvent),
133 "::",
134 stringify!(data)
135 )
136 );
137 assert_eq!(
138 unsafe { &(*(::std::ptr::null::<spEvent>())).time as *const _ as usize },
139 8usize,
140 concat!(
141 "Offset of field: ",
142 stringify!(spEvent),
143 "::",
144 stringify!(time)
145 )
146 );
147 assert_eq!(
148 unsafe { &(*(::std::ptr::null::<spEvent>())).intValue as *const _ as usize },
149 12usize,
150 concat!(
151 "Offset of field: ",
152 stringify!(spEvent),
153 "::",
154 stringify!(intValue)
155 )
156 );
157 assert_eq!(
158 unsafe { &(*(::std::ptr::null::<spEvent>())).floatValue as *const _ as usize },
159 16usize,
160 concat!(
161 "Offset of field: ",
162 stringify!(spEvent),
163 "::",
164 stringify!(floatValue)
165 )
166 );
167 assert_eq!(
168 unsafe { &(*(::std::ptr::null::<spEvent>())).stringValue as *const _ as usize },
169 24usize,
170 concat!(
171 "Offset of field: ",
172 stringify!(spEvent),
173 "::",
174 stringify!(stringValue)
175 )
176 );
177 assert_eq!(
178 unsafe { &(*(::std::ptr::null::<spEvent>())).volume as *const _ as usize },
179 32usize,
180 concat!(
181 "Offset of field: ",
182 stringify!(spEvent),
183 "::",
184 stringify!(volume)
185 )
186 );
187 assert_eq!(
188 unsafe { &(*(::std::ptr::null::<spEvent>())).balance as *const _ as usize },
189 36usize,
190 concat!(
191 "Offset of field: ",
192 stringify!(spEvent),
193 "::",
194 stringify!(balance)
195 )
196 );
197}
198extern "C" {
199 pub fn spEvent_create(time: f32, data: *mut spEventData) -> *mut spEvent;
200}
201extern "C" {
202 pub fn spEvent_dispose(self_: *mut spEvent);
203}
204pub const spAttachmentType_SP_ATTACHMENT_REGION: spAttachmentType = 0;
205pub const spAttachmentType_SP_ATTACHMENT_BOUNDING_BOX: spAttachmentType = 1;
206pub const spAttachmentType_SP_ATTACHMENT_MESH: spAttachmentType = 2;
207pub const spAttachmentType_SP_ATTACHMENT_LINKED_MESH: spAttachmentType = 3;
208pub const spAttachmentType_SP_ATTACHMENT_PATH: spAttachmentType = 4;
209pub const spAttachmentType_SP_ATTACHMENT_POINT: spAttachmentType = 5;
210pub const spAttachmentType_SP_ATTACHMENT_CLIPPING: spAttachmentType = 6;
211pub type spAttachmentType = u32;
212#[repr(C)]
213#[derive(Debug, Copy, Clone)]
214pub struct spAttachment {
215 pub name: *const ::std::os::raw::c_char,
216 pub type_: spAttachmentType,
217 pub vtable: *const ::std::os::raw::c_void,
218 pub refCount: ::std::os::raw::c_int,
219 pub attachmentLoader: *mut spAttachmentLoader,
220}
221#[test]
222fn bindgen_test_layout_spAttachment() {
223 assert_eq!(
224 ::std::mem::size_of::<spAttachment>(),
225 40usize,
226 concat!("Size of: ", stringify!(spAttachment))
227 );
228 assert_eq!(
229 ::std::mem::align_of::<spAttachment>(),
230 8usize,
231 concat!("Alignment of ", stringify!(spAttachment))
232 );
233 assert_eq!(
234 unsafe { &(*(::std::ptr::null::<spAttachment>())).name as *const _ as usize },
235 0usize,
236 concat!(
237 "Offset of field: ",
238 stringify!(spAttachment),
239 "::",
240 stringify!(name)
241 )
242 );
243 assert_eq!(
244 unsafe { &(*(::std::ptr::null::<spAttachment>())).type_ as *const _ as usize },
245 8usize,
246 concat!(
247 "Offset of field: ",
248 stringify!(spAttachment),
249 "::",
250 stringify!(type_)
251 )
252 );
253 assert_eq!(
254 unsafe { &(*(::std::ptr::null::<spAttachment>())).vtable as *const _ as usize },
255 16usize,
256 concat!(
257 "Offset of field: ",
258 stringify!(spAttachment),
259 "::",
260 stringify!(vtable)
261 )
262 );
263 assert_eq!(
264 unsafe { &(*(::std::ptr::null::<spAttachment>())).refCount as *const _ as usize },
265 24usize,
266 concat!(
267 "Offset of field: ",
268 stringify!(spAttachment),
269 "::",
270 stringify!(refCount)
271 )
272 );
273 assert_eq!(
274 unsafe { &(*(::std::ptr::null::<spAttachment>())).attachmentLoader as *const _ as usize },
275 32usize,
276 concat!(
277 "Offset of field: ",
278 stringify!(spAttachment),
279 "::",
280 stringify!(attachmentLoader)
281 )
282 );
283}
284extern "C" {
285 pub fn spAttachment_dispose(self_: *mut spAttachment);
286}
287extern "C" {
288 pub fn spAttachment_copy(self_: *mut spAttachment) -> *mut spAttachment;
289}
290#[repr(C)]
291#[derive(Debug, Copy, Clone)]
292pub struct spAnimation {
293 pub name: *const ::std::os::raw::c_char,
294 pub duration: f32,
295 pub timelinesCount: ::std::os::raw::c_int,
296 pub timelines: *mut *mut spTimeline,
297}
298#[test]
299fn bindgen_test_layout_spAnimation() {
300 assert_eq!(
301 ::std::mem::size_of::<spAnimation>(),
302 24usize,
303 concat!("Size of: ", stringify!(spAnimation))
304 );
305 assert_eq!(
306 ::std::mem::align_of::<spAnimation>(),
307 8usize,
308 concat!("Alignment of ", stringify!(spAnimation))
309 );
310 assert_eq!(
311 unsafe { &(*(::std::ptr::null::<spAnimation>())).name as *const _ as usize },
312 0usize,
313 concat!(
314 "Offset of field: ",
315 stringify!(spAnimation),
316 "::",
317 stringify!(name)
318 )
319 );
320 assert_eq!(
321 unsafe { &(*(::std::ptr::null::<spAnimation>())).duration as *const _ as usize },
322 8usize,
323 concat!(
324 "Offset of field: ",
325 stringify!(spAnimation),
326 "::",
327 stringify!(duration)
328 )
329 );
330 assert_eq!(
331 unsafe { &(*(::std::ptr::null::<spAnimation>())).timelinesCount as *const _ as usize },
332 12usize,
333 concat!(
334 "Offset of field: ",
335 stringify!(spAnimation),
336 "::",
337 stringify!(timelinesCount)
338 )
339 );
340 assert_eq!(
341 unsafe { &(*(::std::ptr::null::<spAnimation>())).timelines as *const _ as usize },
342 16usize,
343 concat!(
344 "Offset of field: ",
345 stringify!(spAnimation),
346 "::",
347 stringify!(timelines)
348 )
349 );
350}
351pub const spMixBlend_SP_MIX_BLEND_SETUP: spMixBlend = 0;
352pub const spMixBlend_SP_MIX_BLEND_FIRST: spMixBlend = 1;
353pub const spMixBlend_SP_MIX_BLEND_REPLACE: spMixBlend = 2;
354pub const spMixBlend_SP_MIX_BLEND_ADD: spMixBlend = 3;
355pub type spMixBlend = u32;
356pub const spMixDirection_SP_MIX_DIRECTION_IN: spMixDirection = 0;
357pub const spMixDirection_SP_MIX_DIRECTION_OUT: spMixDirection = 1;
358pub type spMixDirection = u32;
359extern "C" {
360 pub fn spAnimation_create(
361 name: *const ::std::os::raw::c_char,
362 timelinesCount: ::std::os::raw::c_int,
363 ) -> *mut spAnimation;
364}
365extern "C" {
366 pub fn spAnimation_dispose(self_: *mut spAnimation);
367}
368extern "C" {
369 #[doc = " Poses the skeleton at the specified time for this animation."]
370 #[doc = " @param lastTime The last time the animation was applied."]
371 #[doc = " @param events Any triggered events are added. May be null."]
372 pub fn spAnimation_apply(
373 self_: *const spAnimation,
374 skeleton: *mut spSkeleton,
375 lastTime: f32,
376 time: f32,
377 loop_: ::std::os::raw::c_int,
378 events: *mut *mut spEvent,
379 eventsCount: *mut ::std::os::raw::c_int,
380 alpha: f32,
381 blend: spMixBlend,
382 direction: spMixDirection,
383 );
384}
385pub const spTimelineType_SP_TIMELINE_ROTATE: spTimelineType = 0;
386pub const spTimelineType_SP_TIMELINE_TRANSLATE: spTimelineType = 1;
387pub const spTimelineType_SP_TIMELINE_SCALE: spTimelineType = 2;
388pub const spTimelineType_SP_TIMELINE_SHEAR: spTimelineType = 3;
389pub const spTimelineType_SP_TIMELINE_ATTACHMENT: spTimelineType = 4;
390pub const spTimelineType_SP_TIMELINE_COLOR: spTimelineType = 5;
391pub const spTimelineType_SP_TIMELINE_DEFORM: spTimelineType = 6;
392pub const spTimelineType_SP_TIMELINE_EVENT: spTimelineType = 7;
393pub const spTimelineType_SP_TIMELINE_DRAWORDER: spTimelineType = 8;
394pub const spTimelineType_SP_TIMELINE_IKCONSTRAINT: spTimelineType = 9;
395pub const spTimelineType_SP_TIMELINE_TRANSFORMCONSTRAINT: spTimelineType = 10;
396pub const spTimelineType_SP_TIMELINE_PATHCONSTRAINTPOSITION: spTimelineType = 11;
397pub const spTimelineType_SP_TIMELINE_PATHCONSTRAINTSPACING: spTimelineType = 12;
398pub const spTimelineType_SP_TIMELINE_PATHCONSTRAINTMIX: spTimelineType = 13;
399pub const spTimelineType_SP_TIMELINE_TWOCOLOR: spTimelineType = 14;
400pub type spTimelineType = u32;
401#[repr(C)]
402#[derive(Debug, Copy, Clone)]
403pub struct spTimeline {
404 pub type_: spTimelineType,
405 pub vtable: *const ::std::os::raw::c_void,
406}
407#[test]
408fn bindgen_test_layout_spTimeline() {
409 assert_eq!(
410 ::std::mem::size_of::<spTimeline>(),
411 16usize,
412 concat!("Size of: ", stringify!(spTimeline))
413 );
414 assert_eq!(
415 ::std::mem::align_of::<spTimeline>(),
416 8usize,
417 concat!("Alignment of ", stringify!(spTimeline))
418 );
419 assert_eq!(
420 unsafe { &(*(::std::ptr::null::<spTimeline>())).type_ as *const _ as usize },
421 0usize,
422 concat!(
423 "Offset of field: ",
424 stringify!(spTimeline),
425 "::",
426 stringify!(type_)
427 )
428 );
429 assert_eq!(
430 unsafe { &(*(::std::ptr::null::<spTimeline>())).vtable as *const _ as usize },
431 8usize,
432 concat!(
433 "Offset of field: ",
434 stringify!(spTimeline),
435 "::",
436 stringify!(vtable)
437 )
438 );
439}
440extern "C" {
441 pub fn spTimeline_dispose(self_: *mut spTimeline);
442}
443extern "C" {
444 pub fn spTimeline_apply(
445 self_: *const spTimeline,
446 skeleton: *mut spSkeleton,
447 lastTime: f32,
448 time: f32,
449 firedEvents: *mut *mut spEvent,
450 eventsCount: *mut ::std::os::raw::c_int,
451 alpha: f32,
452 blend: spMixBlend,
453 direction: spMixDirection,
454 );
455}
456extern "C" {
457 pub fn spTimeline_getPropertyId(self_: *const spTimeline) -> ::std::os::raw::c_int;
458}
459#[repr(C)]
460#[derive(Debug, Copy, Clone)]
461pub struct spCurveTimeline {
462 pub super_: spTimeline,
463 pub curves: *mut f32,
464}
465#[test]
466fn bindgen_test_layout_spCurveTimeline() {
467 assert_eq!(
468 ::std::mem::size_of::<spCurveTimeline>(),
469 24usize,
470 concat!("Size of: ", stringify!(spCurveTimeline))
471 );
472 assert_eq!(
473 ::std::mem::align_of::<spCurveTimeline>(),
474 8usize,
475 concat!("Alignment of ", stringify!(spCurveTimeline))
476 );
477 assert_eq!(
478 unsafe { &(*(::std::ptr::null::<spCurveTimeline>())).super_ as *const _ as usize },
479 0usize,
480 concat!(
481 "Offset of field: ",
482 stringify!(spCurveTimeline),
483 "::",
484 stringify!(super_)
485 )
486 );
487 assert_eq!(
488 unsafe { &(*(::std::ptr::null::<spCurveTimeline>())).curves as *const _ as usize },
489 16usize,
490 concat!(
491 "Offset of field: ",
492 stringify!(spCurveTimeline),
493 "::",
494 stringify!(curves)
495 )
496 );
497}
498extern "C" {
499 pub fn spCurveTimeline_setLinear(
500 self_: *mut spCurveTimeline,
501 frameIndex: ::std::os::raw::c_int,
502 );
503}
504extern "C" {
505 pub fn spCurveTimeline_setStepped(
506 self_: *mut spCurveTimeline,
507 frameIndex: ::std::os::raw::c_int,
508 );
509}
510extern "C" {
511 pub fn spCurveTimeline_setCurve(
512 self_: *mut spCurveTimeline,
513 frameIndex: ::std::os::raw::c_int,
514 cx1: f32,
515 cy1: f32,
516 cx2: f32,
517 cy2: f32,
518 );
519}
520extern "C" {
521 pub fn spCurveTimeline_getCurvePercent(
522 self_: *const spCurveTimeline,
523 frameIndex: ::std::os::raw::c_int,
524 percent: f32,
525 ) -> f32;
526}
527#[repr(C)]
528#[derive(Debug, Copy, Clone)]
529pub struct spBaseTimeline {
530 pub super_: spCurveTimeline,
531 pub framesCount: ::std::os::raw::c_int,
532 pub frames: *mut f32,
533 pub boneIndex: ::std::os::raw::c_int,
534}
535#[test]
536fn bindgen_test_layout_spBaseTimeline() {
537 assert_eq!(
538 ::std::mem::size_of::<spBaseTimeline>(),
539 48usize,
540 concat!("Size of: ", stringify!(spBaseTimeline))
541 );
542 assert_eq!(
543 ::std::mem::align_of::<spBaseTimeline>(),
544 8usize,
545 concat!("Alignment of ", stringify!(spBaseTimeline))
546 );
547 assert_eq!(
548 unsafe { &(*(::std::ptr::null::<spBaseTimeline>())).super_ as *const _ as usize },
549 0usize,
550 concat!(
551 "Offset of field: ",
552 stringify!(spBaseTimeline),
553 "::",
554 stringify!(super_)
555 )
556 );
557 assert_eq!(
558 unsafe { &(*(::std::ptr::null::<spBaseTimeline>())).framesCount as *const _ as usize },
559 24usize,
560 concat!(
561 "Offset of field: ",
562 stringify!(spBaseTimeline),
563 "::",
564 stringify!(framesCount)
565 )
566 );
567 assert_eq!(
568 unsafe { &(*(::std::ptr::null::<spBaseTimeline>())).frames as *const _ as usize },
569 32usize,
570 concat!(
571 "Offset of field: ",
572 stringify!(spBaseTimeline),
573 "::",
574 stringify!(frames)
575 )
576 );
577 assert_eq!(
578 unsafe { &(*(::std::ptr::null::<spBaseTimeline>())).boneIndex as *const _ as usize },
579 40usize,
580 concat!(
581 "Offset of field: ",
582 stringify!(spBaseTimeline),
583 "::",
584 stringify!(boneIndex)
585 )
586 );
587}
588pub const ROTATE_PREV_TIME: ::std::os::raw::c_int = -2;
589pub const ROTATE_PREV_ROTATION: ::std::os::raw::c_int = -1;
590pub const ROTATE_ROTATION: ::std::os::raw::c_int = 1;
591pub const ROTATE_ENTRIES: ::std::os::raw::c_int = 2;
592pub type spRotateTimeline = spBaseTimeline;
593extern "C" {
594 pub fn spRotateTimeline_create(framesCount: ::std::os::raw::c_int) -> *mut spRotateTimeline;
595}
596extern "C" {
597 pub fn spRotateTimeline_setFrame(
598 self_: *mut spRotateTimeline,
599 frameIndex: ::std::os::raw::c_int,
600 time: f32,
601 angle: f32,
602 );
603}
604pub const TRANSLATE_ENTRIES: ::std::os::raw::c_int = 3;
605pub type spTranslateTimeline = spBaseTimeline;
606extern "C" {
607 pub fn spTranslateTimeline_create(
608 framesCount: ::std::os::raw::c_int,
609 ) -> *mut spTranslateTimeline;
610}
611extern "C" {
612 pub fn spTranslateTimeline_setFrame(
613 self_: *mut spTranslateTimeline,
614 frameIndex: ::std::os::raw::c_int,
615 time: f32,
616 x: f32,
617 y: f32,
618 );
619}
620pub type spScaleTimeline = spBaseTimeline;
621extern "C" {
622 pub fn spScaleTimeline_create(framesCount: ::std::os::raw::c_int) -> *mut spScaleTimeline;
623}
624extern "C" {
625 pub fn spScaleTimeline_setFrame(
626 self_: *mut spScaleTimeline,
627 frameIndex: ::std::os::raw::c_int,
628 time: f32,
629 x: f32,
630 y: f32,
631 );
632}
633pub type spShearTimeline = spBaseTimeline;
634extern "C" {
635 pub fn spShearTimeline_create(framesCount: ::std::os::raw::c_int) -> *mut spShearTimeline;
636}
637extern "C" {
638 pub fn spShearTimeline_setFrame(
639 self_: *mut spShearTimeline,
640 frameIndex: ::std::os::raw::c_int,
641 time: f32,
642 x: f32,
643 y: f32,
644 );
645}
646pub const COLOR_ENTRIES: ::std::os::raw::c_int = 5;
647#[repr(C)]
648#[derive(Debug, Copy, Clone)]
649pub struct spColorTimeline {
650 pub super_: spCurveTimeline,
651 pub framesCount: ::std::os::raw::c_int,
652 pub frames: *mut f32,
653 pub slotIndex: ::std::os::raw::c_int,
654}
655#[test]
656fn bindgen_test_layout_spColorTimeline() {
657 assert_eq!(
658 ::std::mem::size_of::<spColorTimeline>(),
659 48usize,
660 concat!("Size of: ", stringify!(spColorTimeline))
661 );
662 assert_eq!(
663 ::std::mem::align_of::<spColorTimeline>(),
664 8usize,
665 concat!("Alignment of ", stringify!(spColorTimeline))
666 );
667 assert_eq!(
668 unsafe { &(*(::std::ptr::null::<spColorTimeline>())).super_ as *const _ as usize },
669 0usize,
670 concat!(
671 "Offset of field: ",
672 stringify!(spColorTimeline),
673 "::",
674 stringify!(super_)
675 )
676 );
677 assert_eq!(
678 unsafe { &(*(::std::ptr::null::<spColorTimeline>())).framesCount as *const _ as usize },
679 24usize,
680 concat!(
681 "Offset of field: ",
682 stringify!(spColorTimeline),
683 "::",
684 stringify!(framesCount)
685 )
686 );
687 assert_eq!(
688 unsafe { &(*(::std::ptr::null::<spColorTimeline>())).frames as *const _ as usize },
689 32usize,
690 concat!(
691 "Offset of field: ",
692 stringify!(spColorTimeline),
693 "::",
694 stringify!(frames)
695 )
696 );
697 assert_eq!(
698 unsafe { &(*(::std::ptr::null::<spColorTimeline>())).slotIndex as *const _ as usize },
699 40usize,
700 concat!(
701 "Offset of field: ",
702 stringify!(spColorTimeline),
703 "::",
704 stringify!(slotIndex)
705 )
706 );
707}
708extern "C" {
709 pub fn spColorTimeline_create(framesCount: ::std::os::raw::c_int) -> *mut spColorTimeline;
710}
711extern "C" {
712 pub fn spColorTimeline_setFrame(
713 self_: *mut spColorTimeline,
714 frameIndex: ::std::os::raw::c_int,
715 time: f32,
716 r: f32,
717 g: f32,
718 b: f32,
719 a: f32,
720 );
721}
722pub const TWOCOLOR_ENTRIES: ::std::os::raw::c_int = 8;
723#[repr(C)]
724#[derive(Debug, Copy, Clone)]
725pub struct spTwoColorTimeline {
726 pub super_: spCurveTimeline,
727 pub framesCount: ::std::os::raw::c_int,
728 pub frames: *mut f32,
729 pub slotIndex: ::std::os::raw::c_int,
730}
731#[test]
732fn bindgen_test_layout_spTwoColorTimeline() {
733 assert_eq!(
734 ::std::mem::size_of::<spTwoColorTimeline>(),
735 48usize,
736 concat!("Size of: ", stringify!(spTwoColorTimeline))
737 );
738 assert_eq!(
739 ::std::mem::align_of::<spTwoColorTimeline>(),
740 8usize,
741 concat!("Alignment of ", stringify!(spTwoColorTimeline))
742 );
743 assert_eq!(
744 unsafe { &(*(::std::ptr::null::<spTwoColorTimeline>())).super_ as *const _ as usize },
745 0usize,
746 concat!(
747 "Offset of field: ",
748 stringify!(spTwoColorTimeline),
749 "::",
750 stringify!(super_)
751 )
752 );
753 assert_eq!(
754 unsafe { &(*(::std::ptr::null::<spTwoColorTimeline>())).framesCount as *const _ as usize },
755 24usize,
756 concat!(
757 "Offset of field: ",
758 stringify!(spTwoColorTimeline),
759 "::",
760 stringify!(framesCount)
761 )
762 );
763 assert_eq!(
764 unsafe { &(*(::std::ptr::null::<spTwoColorTimeline>())).frames as *const _ as usize },
765 32usize,
766 concat!(
767 "Offset of field: ",
768 stringify!(spTwoColorTimeline),
769 "::",
770 stringify!(frames)
771 )
772 );
773 assert_eq!(
774 unsafe { &(*(::std::ptr::null::<spTwoColorTimeline>())).slotIndex as *const _ as usize },
775 40usize,
776 concat!(
777 "Offset of field: ",
778 stringify!(spTwoColorTimeline),
779 "::",
780 stringify!(slotIndex)
781 )
782 );
783}
784extern "C" {
785 pub fn spTwoColorTimeline_create(framesCount: ::std::os::raw::c_int)
786 -> *mut spTwoColorTimeline;
787}
788extern "C" {
789 pub fn spTwoColorTimeline_setFrame(
790 self_: *mut spTwoColorTimeline,
791 frameIndex: ::std::os::raw::c_int,
792 time: f32,
793 r: f32,
794 g: f32,
795 b: f32,
796 a: f32,
797 r2: f32,
798 g2: f32,
799 b2: f32,
800 );
801}
802#[repr(C)]
803#[derive(Debug, Copy, Clone)]
804pub struct spAttachmentTimeline {
805 pub super_: spTimeline,
806 pub framesCount: ::std::os::raw::c_int,
807 pub frames: *mut f32,
808 pub slotIndex: ::std::os::raw::c_int,
809 pub attachmentNames: *mut *const ::std::os::raw::c_char,
810}
811#[test]
812fn bindgen_test_layout_spAttachmentTimeline() {
813 assert_eq!(
814 ::std::mem::size_of::<spAttachmentTimeline>(),
815 48usize,
816 concat!("Size of: ", stringify!(spAttachmentTimeline))
817 );
818 assert_eq!(
819 ::std::mem::align_of::<spAttachmentTimeline>(),
820 8usize,
821 concat!("Alignment of ", stringify!(spAttachmentTimeline))
822 );
823 assert_eq!(
824 unsafe { &(*(::std::ptr::null::<spAttachmentTimeline>())).super_ as *const _ as usize },
825 0usize,
826 concat!(
827 "Offset of field: ",
828 stringify!(spAttachmentTimeline),
829 "::",
830 stringify!(super_)
831 )
832 );
833 assert_eq!(
834 unsafe {
835 &(*(::std::ptr::null::<spAttachmentTimeline>())).framesCount as *const _ as usize
836 },
837 16usize,
838 concat!(
839 "Offset of field: ",
840 stringify!(spAttachmentTimeline),
841 "::",
842 stringify!(framesCount)
843 )
844 );
845 assert_eq!(
846 unsafe { &(*(::std::ptr::null::<spAttachmentTimeline>())).frames as *const _ as usize },
847 24usize,
848 concat!(
849 "Offset of field: ",
850 stringify!(spAttachmentTimeline),
851 "::",
852 stringify!(frames)
853 )
854 );
855 assert_eq!(
856 unsafe { &(*(::std::ptr::null::<spAttachmentTimeline>())).slotIndex as *const _ as usize },
857 32usize,
858 concat!(
859 "Offset of field: ",
860 stringify!(spAttachmentTimeline),
861 "::",
862 stringify!(slotIndex)
863 )
864 );
865 assert_eq!(
866 unsafe {
867 &(*(::std::ptr::null::<spAttachmentTimeline>())).attachmentNames as *const _ as usize
868 },
869 40usize,
870 concat!(
871 "Offset of field: ",
872 stringify!(spAttachmentTimeline),
873 "::",
874 stringify!(attachmentNames)
875 )
876 );
877}
878extern "C" {
879 pub fn spAttachmentTimeline_create(
880 framesCount: ::std::os::raw::c_int,
881 ) -> *mut spAttachmentTimeline;
882}
883extern "C" {
884 pub fn spAttachmentTimeline_setFrame(
885 self_: *mut spAttachmentTimeline,
886 frameIndex: ::std::os::raw::c_int,
887 time: f32,
888 attachmentName: *const ::std::os::raw::c_char,
889 );
890}
891#[repr(C)]
892#[derive(Debug, Copy, Clone)]
893pub struct spEventTimeline {
894 pub super_: spTimeline,
895 pub framesCount: ::std::os::raw::c_int,
896 pub frames: *mut f32,
897 pub events: *mut *mut spEvent,
898}
899#[test]
900fn bindgen_test_layout_spEventTimeline() {
901 assert_eq!(
902 ::std::mem::size_of::<spEventTimeline>(),
903 40usize,
904 concat!("Size of: ", stringify!(spEventTimeline))
905 );
906 assert_eq!(
907 ::std::mem::align_of::<spEventTimeline>(),
908 8usize,
909 concat!("Alignment of ", stringify!(spEventTimeline))
910 );
911 assert_eq!(
912 unsafe { &(*(::std::ptr::null::<spEventTimeline>())).super_ as *const _ as usize },
913 0usize,
914 concat!(
915 "Offset of field: ",
916 stringify!(spEventTimeline),
917 "::",
918 stringify!(super_)
919 )
920 );
921 assert_eq!(
922 unsafe { &(*(::std::ptr::null::<spEventTimeline>())).framesCount as *const _ as usize },
923 16usize,
924 concat!(
925 "Offset of field: ",
926 stringify!(spEventTimeline),
927 "::",
928 stringify!(framesCount)
929 )
930 );
931 assert_eq!(
932 unsafe { &(*(::std::ptr::null::<spEventTimeline>())).frames as *const _ as usize },
933 24usize,
934 concat!(
935 "Offset of field: ",
936 stringify!(spEventTimeline),
937 "::",
938 stringify!(frames)
939 )
940 );
941 assert_eq!(
942 unsafe { &(*(::std::ptr::null::<spEventTimeline>())).events as *const _ as usize },
943 32usize,
944 concat!(
945 "Offset of field: ",
946 stringify!(spEventTimeline),
947 "::",
948 stringify!(events)
949 )
950 );
951}
952extern "C" {
953 pub fn spEventTimeline_create(framesCount: ::std::os::raw::c_int) -> *mut spEventTimeline;
954}
955extern "C" {
956 pub fn spEventTimeline_setFrame(
957 self_: *mut spEventTimeline,
958 frameIndex: ::std::os::raw::c_int,
959 event: *mut spEvent,
960 );
961}
962#[repr(C)]
963#[derive(Debug, Copy, Clone)]
964pub struct spDrawOrderTimeline {
965 pub super_: spTimeline,
966 pub framesCount: ::std::os::raw::c_int,
967 pub frames: *mut f32,
968 pub drawOrders: *mut *const ::std::os::raw::c_int,
969 pub slotsCount: ::std::os::raw::c_int,
970}
971#[test]
972fn bindgen_test_layout_spDrawOrderTimeline() {
973 assert_eq!(
974 ::std::mem::size_of::<spDrawOrderTimeline>(),
975 48usize,
976 concat!("Size of: ", stringify!(spDrawOrderTimeline))
977 );
978 assert_eq!(
979 ::std::mem::align_of::<spDrawOrderTimeline>(),
980 8usize,
981 concat!("Alignment of ", stringify!(spDrawOrderTimeline))
982 );
983 assert_eq!(
984 unsafe { &(*(::std::ptr::null::<spDrawOrderTimeline>())).super_ as *const _ as usize },
985 0usize,
986 concat!(
987 "Offset of field: ",
988 stringify!(spDrawOrderTimeline),
989 "::",
990 stringify!(super_)
991 )
992 );
993 assert_eq!(
994 unsafe { &(*(::std::ptr::null::<spDrawOrderTimeline>())).framesCount as *const _ as usize },
995 16usize,
996 concat!(
997 "Offset of field: ",
998 stringify!(spDrawOrderTimeline),
999 "::",
1000 stringify!(framesCount)
1001 )
1002 );
1003 assert_eq!(
1004 unsafe { &(*(::std::ptr::null::<spDrawOrderTimeline>())).frames as *const _ as usize },
1005 24usize,
1006 concat!(
1007 "Offset of field: ",
1008 stringify!(spDrawOrderTimeline),
1009 "::",
1010 stringify!(frames)
1011 )
1012 );
1013 assert_eq!(
1014 unsafe { &(*(::std::ptr::null::<spDrawOrderTimeline>())).drawOrders as *const _ as usize },
1015 32usize,
1016 concat!(
1017 "Offset of field: ",
1018 stringify!(spDrawOrderTimeline),
1019 "::",
1020 stringify!(drawOrders)
1021 )
1022 );
1023 assert_eq!(
1024 unsafe { &(*(::std::ptr::null::<spDrawOrderTimeline>())).slotsCount as *const _ as usize },
1025 40usize,
1026 concat!(
1027 "Offset of field: ",
1028 stringify!(spDrawOrderTimeline),
1029 "::",
1030 stringify!(slotsCount)
1031 )
1032 );
1033}
1034extern "C" {
1035 pub fn spDrawOrderTimeline_create(
1036 framesCount: ::std::os::raw::c_int,
1037 slotsCount: ::std::os::raw::c_int,
1038 ) -> *mut spDrawOrderTimeline;
1039}
1040extern "C" {
1041 pub fn spDrawOrderTimeline_setFrame(
1042 self_: *mut spDrawOrderTimeline,
1043 frameIndex: ::std::os::raw::c_int,
1044 time: f32,
1045 drawOrder: *const ::std::os::raw::c_int,
1046 );
1047}
1048#[repr(C)]
1049#[derive(Debug, Copy, Clone)]
1050pub struct spDeformTimeline {
1051 pub super_: spCurveTimeline,
1052 pub framesCount: ::std::os::raw::c_int,
1053 pub frames: *mut f32,
1054 pub frameVerticesCount: ::std::os::raw::c_int,
1055 pub frameVertices: *mut *const f32,
1056 pub slotIndex: ::std::os::raw::c_int,
1057 pub attachment: *mut spAttachment,
1058}
1059#[test]
1060fn bindgen_test_layout_spDeformTimeline() {
1061 assert_eq!(
1062 ::std::mem::size_of::<spDeformTimeline>(),
1063 72usize,
1064 concat!("Size of: ", stringify!(spDeformTimeline))
1065 );
1066 assert_eq!(
1067 ::std::mem::align_of::<spDeformTimeline>(),
1068 8usize,
1069 concat!("Alignment of ", stringify!(spDeformTimeline))
1070 );
1071 assert_eq!(
1072 unsafe { &(*(::std::ptr::null::<spDeformTimeline>())).super_ as *const _ as usize },
1073 0usize,
1074 concat!(
1075 "Offset of field: ",
1076 stringify!(spDeformTimeline),
1077 "::",
1078 stringify!(super_)
1079 )
1080 );
1081 assert_eq!(
1082 unsafe { &(*(::std::ptr::null::<spDeformTimeline>())).framesCount as *const _ as usize },
1083 24usize,
1084 concat!(
1085 "Offset of field: ",
1086 stringify!(spDeformTimeline),
1087 "::",
1088 stringify!(framesCount)
1089 )
1090 );
1091 assert_eq!(
1092 unsafe { &(*(::std::ptr::null::<spDeformTimeline>())).frames as *const _ as usize },
1093 32usize,
1094 concat!(
1095 "Offset of field: ",
1096 stringify!(spDeformTimeline),
1097 "::",
1098 stringify!(frames)
1099 )
1100 );
1101 assert_eq!(
1102 unsafe {
1103 &(*(::std::ptr::null::<spDeformTimeline>())).frameVerticesCount as *const _ as usize
1104 },
1105 40usize,
1106 concat!(
1107 "Offset of field: ",
1108 stringify!(spDeformTimeline),
1109 "::",
1110 stringify!(frameVerticesCount)
1111 )
1112 );
1113 assert_eq!(
1114 unsafe { &(*(::std::ptr::null::<spDeformTimeline>())).frameVertices as *const _ as usize },
1115 48usize,
1116 concat!(
1117 "Offset of field: ",
1118 stringify!(spDeformTimeline),
1119 "::",
1120 stringify!(frameVertices)
1121 )
1122 );
1123 assert_eq!(
1124 unsafe { &(*(::std::ptr::null::<spDeformTimeline>())).slotIndex as *const _ as usize },
1125 56usize,
1126 concat!(
1127 "Offset of field: ",
1128 stringify!(spDeformTimeline),
1129 "::",
1130 stringify!(slotIndex)
1131 )
1132 );
1133 assert_eq!(
1134 unsafe { &(*(::std::ptr::null::<spDeformTimeline>())).attachment as *const _ as usize },
1135 64usize,
1136 concat!(
1137 "Offset of field: ",
1138 stringify!(spDeformTimeline),
1139 "::",
1140 stringify!(attachment)
1141 )
1142 );
1143}
1144extern "C" {
1145 pub fn spDeformTimeline_create(
1146 framesCount: ::std::os::raw::c_int,
1147 frameVerticesCount: ::std::os::raw::c_int,
1148 ) -> *mut spDeformTimeline;
1149}
1150extern "C" {
1151 pub fn spDeformTimeline_setFrame(
1152 self_: *mut spDeformTimeline,
1153 frameIndex: ::std::os::raw::c_int,
1154 time: f32,
1155 vertices: *mut f32,
1156 );
1157}
1158pub const IKCONSTRAINT_ENTRIES: ::std::os::raw::c_int = 6;
1159#[repr(C)]
1160#[derive(Debug, Copy, Clone)]
1161pub struct spIkConstraintTimeline {
1162 pub super_: spCurveTimeline,
1163 pub framesCount: ::std::os::raw::c_int,
1164 pub frames: *mut f32,
1165 pub ikConstraintIndex: ::std::os::raw::c_int,
1166}
1167#[test]
1168fn bindgen_test_layout_spIkConstraintTimeline() {
1169 assert_eq!(
1170 ::std::mem::size_of::<spIkConstraintTimeline>(),
1171 48usize,
1172 concat!("Size of: ", stringify!(spIkConstraintTimeline))
1173 );
1174 assert_eq!(
1175 ::std::mem::align_of::<spIkConstraintTimeline>(),
1176 8usize,
1177 concat!("Alignment of ", stringify!(spIkConstraintTimeline))
1178 );
1179 assert_eq!(
1180 unsafe { &(*(::std::ptr::null::<spIkConstraintTimeline>())).super_ as *const _ as usize },
1181 0usize,
1182 concat!(
1183 "Offset of field: ",
1184 stringify!(spIkConstraintTimeline),
1185 "::",
1186 stringify!(super_)
1187 )
1188 );
1189 assert_eq!(
1190 unsafe {
1191 &(*(::std::ptr::null::<spIkConstraintTimeline>())).framesCount as *const _ as usize
1192 },
1193 24usize,
1194 concat!(
1195 "Offset of field: ",
1196 stringify!(spIkConstraintTimeline),
1197 "::",
1198 stringify!(framesCount)
1199 )
1200 );
1201 assert_eq!(
1202 unsafe { &(*(::std::ptr::null::<spIkConstraintTimeline>())).frames as *const _ as usize },
1203 32usize,
1204 concat!(
1205 "Offset of field: ",
1206 stringify!(spIkConstraintTimeline),
1207 "::",
1208 stringify!(frames)
1209 )
1210 );
1211 assert_eq!(
1212 unsafe {
1213 &(*(::std::ptr::null::<spIkConstraintTimeline>())).ikConstraintIndex as *const _
1214 as usize
1215 },
1216 40usize,
1217 concat!(
1218 "Offset of field: ",
1219 stringify!(spIkConstraintTimeline),
1220 "::",
1221 stringify!(ikConstraintIndex)
1222 )
1223 );
1224}
1225extern "C" {
1226 pub fn spIkConstraintTimeline_create(
1227 framesCount: ::std::os::raw::c_int,
1228 ) -> *mut spIkConstraintTimeline;
1229}
1230extern "C" {
1231 pub fn spIkConstraintTimeline_setFrame(
1232 self_: *mut spIkConstraintTimeline,
1233 frameIndex: ::std::os::raw::c_int,
1234 time: f32,
1235 mix: f32,
1236 softness: f32,
1237 bendDirection: ::std::os::raw::c_int,
1238 compress: ::std::os::raw::c_int,
1239 stretch: ::std::os::raw::c_int,
1240 );
1241}
1242pub const TRANSFORMCONSTRAINT_ENTRIES: ::std::os::raw::c_int = 5;
1243#[repr(C)]
1244#[derive(Debug, Copy, Clone)]
1245pub struct spTransformConstraintTimeline {
1246 pub super_: spCurveTimeline,
1247 pub framesCount: ::std::os::raw::c_int,
1248 pub frames: *mut f32,
1249 pub transformConstraintIndex: ::std::os::raw::c_int,
1250}
1251#[test]
1252fn bindgen_test_layout_spTransformConstraintTimeline() {
1253 assert_eq!(
1254 ::std::mem::size_of::<spTransformConstraintTimeline>(),
1255 48usize,
1256 concat!("Size of: ", stringify!(spTransformConstraintTimeline))
1257 );
1258 assert_eq!(
1259 ::std::mem::align_of::<spTransformConstraintTimeline>(),
1260 8usize,
1261 concat!("Alignment of ", stringify!(spTransformConstraintTimeline))
1262 );
1263 assert_eq!(
1264 unsafe {
1265 &(*(::std::ptr::null::<spTransformConstraintTimeline>())).super_ as *const _ as usize
1266 },
1267 0usize,
1268 concat!(
1269 "Offset of field: ",
1270 stringify!(spTransformConstraintTimeline),
1271 "::",
1272 stringify!(super_)
1273 )
1274 );
1275 assert_eq!(
1276 unsafe {
1277 &(*(::std::ptr::null::<spTransformConstraintTimeline>())).framesCount as *const _
1278 as usize
1279 },
1280 24usize,
1281 concat!(
1282 "Offset of field: ",
1283 stringify!(spTransformConstraintTimeline),
1284 "::",
1285 stringify!(framesCount)
1286 )
1287 );
1288 assert_eq!(
1289 unsafe {
1290 &(*(::std::ptr::null::<spTransformConstraintTimeline>())).frames as *const _ as usize
1291 },
1292 32usize,
1293 concat!(
1294 "Offset of field: ",
1295 stringify!(spTransformConstraintTimeline),
1296 "::",
1297 stringify!(frames)
1298 )
1299 );
1300 assert_eq!(
1301 unsafe {
1302 &(*(::std::ptr::null::<spTransformConstraintTimeline>())).transformConstraintIndex
1303 as *const _ as usize
1304 },
1305 40usize,
1306 concat!(
1307 "Offset of field: ",
1308 stringify!(spTransformConstraintTimeline),
1309 "::",
1310 stringify!(transformConstraintIndex)
1311 )
1312 );
1313}
1314extern "C" {
1315 pub fn spTransformConstraintTimeline_create(
1316 framesCount: ::std::os::raw::c_int,
1317 ) -> *mut spTransformConstraintTimeline;
1318}
1319extern "C" {
1320 pub fn spTransformConstraintTimeline_setFrame(
1321 self_: *mut spTransformConstraintTimeline,
1322 frameIndex: ::std::os::raw::c_int,
1323 time: f32,
1324 rotateMix: f32,
1325 translateMix: f32,
1326 scaleMix: f32,
1327 shearMix: f32,
1328 );
1329}
1330pub const PATHCONSTRAINTPOSITION_ENTRIES: ::std::os::raw::c_int = 2;
1331#[repr(C)]
1332#[derive(Debug, Copy, Clone)]
1333pub struct spPathConstraintPositionTimeline {
1334 pub super_: spCurveTimeline,
1335 pub framesCount: ::std::os::raw::c_int,
1336 pub frames: *mut f32,
1337 pub pathConstraintIndex: ::std::os::raw::c_int,
1338}
1339#[test]
1340fn bindgen_test_layout_spPathConstraintPositionTimeline() {
1341 assert_eq!(
1342 ::std::mem::size_of::<spPathConstraintPositionTimeline>(),
1343 48usize,
1344 concat!("Size of: ", stringify!(spPathConstraintPositionTimeline))
1345 );
1346 assert_eq!(
1347 ::std::mem::align_of::<spPathConstraintPositionTimeline>(),
1348 8usize,
1349 concat!(
1350 "Alignment of ",
1351 stringify!(spPathConstraintPositionTimeline)
1352 )
1353 );
1354 assert_eq!(
1355 unsafe {
1356 &(*(::std::ptr::null::<spPathConstraintPositionTimeline>())).super_ as *const _ as usize
1357 },
1358 0usize,
1359 concat!(
1360 "Offset of field: ",
1361 stringify!(spPathConstraintPositionTimeline),
1362 "::",
1363 stringify!(super_)
1364 )
1365 );
1366 assert_eq!(
1367 unsafe {
1368 &(*(::std::ptr::null::<spPathConstraintPositionTimeline>())).framesCount as *const _
1369 as usize
1370 },
1371 24usize,
1372 concat!(
1373 "Offset of field: ",
1374 stringify!(spPathConstraintPositionTimeline),
1375 "::",
1376 stringify!(framesCount)
1377 )
1378 );
1379 assert_eq!(
1380 unsafe {
1381 &(*(::std::ptr::null::<spPathConstraintPositionTimeline>())).frames as *const _ as usize
1382 },
1383 32usize,
1384 concat!(
1385 "Offset of field: ",
1386 stringify!(spPathConstraintPositionTimeline),
1387 "::",
1388 stringify!(frames)
1389 )
1390 );
1391 assert_eq!(
1392 unsafe {
1393 &(*(::std::ptr::null::<spPathConstraintPositionTimeline>())).pathConstraintIndex
1394 as *const _ as usize
1395 },
1396 40usize,
1397 concat!(
1398 "Offset of field: ",
1399 stringify!(spPathConstraintPositionTimeline),
1400 "::",
1401 stringify!(pathConstraintIndex)
1402 )
1403 );
1404}
1405extern "C" {
1406 pub fn spPathConstraintPositionTimeline_create(
1407 framesCount: ::std::os::raw::c_int,
1408 ) -> *mut spPathConstraintPositionTimeline;
1409}
1410extern "C" {
1411 pub fn spPathConstraintPositionTimeline_setFrame(
1412 self_: *mut spPathConstraintPositionTimeline,
1413 frameIndex: ::std::os::raw::c_int,
1414 time: f32,
1415 value: f32,
1416 );
1417}
1418pub const PATHCONSTRAINTSPACING_ENTRIES: ::std::os::raw::c_int = 2;
1419#[repr(C)]
1420#[derive(Debug, Copy, Clone)]
1421pub struct spPathConstraintSpacingTimeline {
1422 pub super_: spCurveTimeline,
1423 pub framesCount: ::std::os::raw::c_int,
1424 pub frames: *mut f32,
1425 pub pathConstraintIndex: ::std::os::raw::c_int,
1426}
1427#[test]
1428fn bindgen_test_layout_spPathConstraintSpacingTimeline() {
1429 assert_eq!(
1430 ::std::mem::size_of::<spPathConstraintSpacingTimeline>(),
1431 48usize,
1432 concat!("Size of: ", stringify!(spPathConstraintSpacingTimeline))
1433 );
1434 assert_eq!(
1435 ::std::mem::align_of::<spPathConstraintSpacingTimeline>(),
1436 8usize,
1437 concat!("Alignment of ", stringify!(spPathConstraintSpacingTimeline))
1438 );
1439 assert_eq!(
1440 unsafe {
1441 &(*(::std::ptr::null::<spPathConstraintSpacingTimeline>())).super_ as *const _ as usize
1442 },
1443 0usize,
1444 concat!(
1445 "Offset of field: ",
1446 stringify!(spPathConstraintSpacingTimeline),
1447 "::",
1448 stringify!(super_)
1449 )
1450 );
1451 assert_eq!(
1452 unsafe {
1453 &(*(::std::ptr::null::<spPathConstraintSpacingTimeline>())).framesCount as *const _
1454 as usize
1455 },
1456 24usize,
1457 concat!(
1458 "Offset of field: ",
1459 stringify!(spPathConstraintSpacingTimeline),
1460 "::",
1461 stringify!(framesCount)
1462 )
1463 );
1464 assert_eq!(
1465 unsafe {
1466 &(*(::std::ptr::null::<spPathConstraintSpacingTimeline>())).frames as *const _ as usize
1467 },
1468 32usize,
1469 concat!(
1470 "Offset of field: ",
1471 stringify!(spPathConstraintSpacingTimeline),
1472 "::",
1473 stringify!(frames)
1474 )
1475 );
1476 assert_eq!(
1477 unsafe {
1478 &(*(::std::ptr::null::<spPathConstraintSpacingTimeline>())).pathConstraintIndex
1479 as *const _ as usize
1480 },
1481 40usize,
1482 concat!(
1483 "Offset of field: ",
1484 stringify!(spPathConstraintSpacingTimeline),
1485 "::",
1486 stringify!(pathConstraintIndex)
1487 )
1488 );
1489}
1490extern "C" {
1491 pub fn spPathConstraintSpacingTimeline_create(
1492 framesCount: ::std::os::raw::c_int,
1493 ) -> *mut spPathConstraintSpacingTimeline;
1494}
1495extern "C" {
1496 pub fn spPathConstraintSpacingTimeline_setFrame(
1497 self_: *mut spPathConstraintSpacingTimeline,
1498 frameIndex: ::std::os::raw::c_int,
1499 time: f32,
1500 value: f32,
1501 );
1502}
1503pub const PATHCONSTRAINTMIX_ENTRIES: ::std::os::raw::c_int = 3;
1504#[repr(C)]
1505#[derive(Debug, Copy, Clone)]
1506pub struct spPathConstraintMixTimeline {
1507 pub super_: spCurveTimeline,
1508 pub framesCount: ::std::os::raw::c_int,
1509 pub frames: *mut f32,
1510 pub pathConstraintIndex: ::std::os::raw::c_int,
1511}
1512#[test]
1513fn bindgen_test_layout_spPathConstraintMixTimeline() {
1514 assert_eq!(
1515 ::std::mem::size_of::<spPathConstraintMixTimeline>(),
1516 48usize,
1517 concat!("Size of: ", stringify!(spPathConstraintMixTimeline))
1518 );
1519 assert_eq!(
1520 ::std::mem::align_of::<spPathConstraintMixTimeline>(),
1521 8usize,
1522 concat!("Alignment of ", stringify!(spPathConstraintMixTimeline))
1523 );
1524 assert_eq!(
1525 unsafe {
1526 &(*(::std::ptr::null::<spPathConstraintMixTimeline>())).super_ as *const _ as usize
1527 },
1528 0usize,
1529 concat!(
1530 "Offset of field: ",
1531 stringify!(spPathConstraintMixTimeline),
1532 "::",
1533 stringify!(super_)
1534 )
1535 );
1536 assert_eq!(
1537 unsafe {
1538 &(*(::std::ptr::null::<spPathConstraintMixTimeline>())).framesCount as *const _ as usize
1539 },
1540 24usize,
1541 concat!(
1542 "Offset of field: ",
1543 stringify!(spPathConstraintMixTimeline),
1544 "::",
1545 stringify!(framesCount)
1546 )
1547 );
1548 assert_eq!(
1549 unsafe {
1550 &(*(::std::ptr::null::<spPathConstraintMixTimeline>())).frames as *const _ as usize
1551 },
1552 32usize,
1553 concat!(
1554 "Offset of field: ",
1555 stringify!(spPathConstraintMixTimeline),
1556 "::",
1557 stringify!(frames)
1558 )
1559 );
1560 assert_eq!(
1561 unsafe {
1562 &(*(::std::ptr::null::<spPathConstraintMixTimeline>())).pathConstraintIndex as *const _
1563 as usize
1564 },
1565 40usize,
1566 concat!(
1567 "Offset of field: ",
1568 stringify!(spPathConstraintMixTimeline),
1569 "::",
1570 stringify!(pathConstraintIndex)
1571 )
1572 );
1573}
1574extern "C" {
1575 pub fn spPathConstraintMixTimeline_create(
1576 framesCount: ::std::os::raw::c_int,
1577 ) -> *mut spPathConstraintMixTimeline;
1578}
1579extern "C" {
1580 pub fn spPathConstraintMixTimeline_setFrame(
1581 self_: *mut spPathConstraintMixTimeline,
1582 frameIndex: ::std::os::raw::c_int,
1583 time: f32,
1584 rotateMix: f32,
1585 translateMix: f32,
1586 );
1587}
1588pub const spTransformMode_SP_TRANSFORMMODE_NORMAL: spTransformMode = 0;
1589pub const spTransformMode_SP_TRANSFORMMODE_ONLYTRANSLATION: spTransformMode = 1;
1590pub const spTransformMode_SP_TRANSFORMMODE_NOROTATIONORREFLECTION: spTransformMode = 2;
1591pub const spTransformMode_SP_TRANSFORMMODE_NOSCALE: spTransformMode = 3;
1592pub const spTransformMode_SP_TRANSFORMMODE_NOSCALEORREFLECTION: spTransformMode = 4;
1593pub type spTransformMode = u32;
1594#[repr(C)]
1595#[derive(Debug, Copy, Clone)]
1596pub struct spBoneData {
1597 pub index: ::std::os::raw::c_int,
1598 pub name: *const ::std::os::raw::c_char,
1599 pub parent: *mut spBoneData,
1600 pub length: f32,
1601 pub x: f32,
1602 pub y: f32,
1603 pub rotation: f32,
1604 pub scaleX: f32,
1605 pub scaleY: f32,
1606 pub shearX: f32,
1607 pub shearY: f32,
1608 pub transformMode: spTransformMode,
1609 pub skinRequired: ::std::os::raw::c_int,
1610}
1611#[test]
1612fn bindgen_test_layout_spBoneData() {
1613 assert_eq!(
1614 ::std::mem::size_of::<spBoneData>(),
1615 64usize,
1616 concat!("Size of: ", stringify!(spBoneData))
1617 );
1618 assert_eq!(
1619 ::std::mem::align_of::<spBoneData>(),
1620 8usize,
1621 concat!("Alignment of ", stringify!(spBoneData))
1622 );
1623 assert_eq!(
1624 unsafe { &(*(::std::ptr::null::<spBoneData>())).index as *const _ as usize },
1625 0usize,
1626 concat!(
1627 "Offset of field: ",
1628 stringify!(spBoneData),
1629 "::",
1630 stringify!(index)
1631 )
1632 );
1633 assert_eq!(
1634 unsafe { &(*(::std::ptr::null::<spBoneData>())).name as *const _ as usize },
1635 8usize,
1636 concat!(
1637 "Offset of field: ",
1638 stringify!(spBoneData),
1639 "::",
1640 stringify!(name)
1641 )
1642 );
1643 assert_eq!(
1644 unsafe { &(*(::std::ptr::null::<spBoneData>())).parent as *const _ as usize },
1645 16usize,
1646 concat!(
1647 "Offset of field: ",
1648 stringify!(spBoneData),
1649 "::",
1650 stringify!(parent)
1651 )
1652 );
1653 assert_eq!(
1654 unsafe { &(*(::std::ptr::null::<spBoneData>())).length as *const _ as usize },
1655 24usize,
1656 concat!(
1657 "Offset of field: ",
1658 stringify!(spBoneData),
1659 "::",
1660 stringify!(length)
1661 )
1662 );
1663 assert_eq!(
1664 unsafe { &(*(::std::ptr::null::<spBoneData>())).x as *const _ as usize },
1665 28usize,
1666 concat!(
1667 "Offset of field: ",
1668 stringify!(spBoneData),
1669 "::",
1670 stringify!(x)
1671 )
1672 );
1673 assert_eq!(
1674 unsafe { &(*(::std::ptr::null::<spBoneData>())).y as *const _ as usize },
1675 32usize,
1676 concat!(
1677 "Offset of field: ",
1678 stringify!(spBoneData),
1679 "::",
1680 stringify!(y)
1681 )
1682 );
1683 assert_eq!(
1684 unsafe { &(*(::std::ptr::null::<spBoneData>())).rotation as *const _ as usize },
1685 36usize,
1686 concat!(
1687 "Offset of field: ",
1688 stringify!(spBoneData),
1689 "::",
1690 stringify!(rotation)
1691 )
1692 );
1693 assert_eq!(
1694 unsafe { &(*(::std::ptr::null::<spBoneData>())).scaleX as *const _ as usize },
1695 40usize,
1696 concat!(
1697 "Offset of field: ",
1698 stringify!(spBoneData),
1699 "::",
1700 stringify!(scaleX)
1701 )
1702 );
1703 assert_eq!(
1704 unsafe { &(*(::std::ptr::null::<spBoneData>())).scaleY as *const _ as usize },
1705 44usize,
1706 concat!(
1707 "Offset of field: ",
1708 stringify!(spBoneData),
1709 "::",
1710 stringify!(scaleY)
1711 )
1712 );
1713 assert_eq!(
1714 unsafe { &(*(::std::ptr::null::<spBoneData>())).shearX as *const _ as usize },
1715 48usize,
1716 concat!(
1717 "Offset of field: ",
1718 stringify!(spBoneData),
1719 "::",
1720 stringify!(shearX)
1721 )
1722 );
1723 assert_eq!(
1724 unsafe { &(*(::std::ptr::null::<spBoneData>())).shearY as *const _ as usize },
1725 52usize,
1726 concat!(
1727 "Offset of field: ",
1728 stringify!(spBoneData),
1729 "::",
1730 stringify!(shearY)
1731 )
1732 );
1733 assert_eq!(
1734 unsafe { &(*(::std::ptr::null::<spBoneData>())).transformMode as *const _ as usize },
1735 56usize,
1736 concat!(
1737 "Offset of field: ",
1738 stringify!(spBoneData),
1739 "::",
1740 stringify!(transformMode)
1741 )
1742 );
1743 assert_eq!(
1744 unsafe { &(*(::std::ptr::null::<spBoneData>())).skinRequired as *const _ as usize },
1745 60usize,
1746 concat!(
1747 "Offset of field: ",
1748 stringify!(spBoneData),
1749 "::",
1750 stringify!(skinRequired)
1751 )
1752 );
1753}
1754extern "C" {
1755 pub fn spBoneData_create(
1756 index: ::std::os::raw::c_int,
1757 name: *const ::std::os::raw::c_char,
1758 parent: *mut spBoneData,
1759 ) -> *mut spBoneData;
1760}
1761extern "C" {
1762 pub fn spBoneData_dispose(self_: *mut spBoneData);
1763}
1764#[repr(C)]
1765#[derive(Debug, Copy, Clone)]
1766pub struct spColor {
1767 pub r: f32,
1768 pub g: f32,
1769 pub b: f32,
1770 pub a: f32,
1771}
1772#[test]
1773fn bindgen_test_layout_spColor() {
1774 assert_eq!(
1775 ::std::mem::size_of::<spColor>(),
1776 16usize,
1777 concat!("Size of: ", stringify!(spColor))
1778 );
1779 assert_eq!(
1780 ::std::mem::align_of::<spColor>(),
1781 4usize,
1782 concat!("Alignment of ", stringify!(spColor))
1783 );
1784 assert_eq!(
1785 unsafe { &(*(::std::ptr::null::<spColor>())).r as *const _ as usize },
1786 0usize,
1787 concat!(
1788 "Offset of field: ",
1789 stringify!(spColor),
1790 "::",
1791 stringify!(r)
1792 )
1793 );
1794 assert_eq!(
1795 unsafe { &(*(::std::ptr::null::<spColor>())).g as *const _ as usize },
1796 4usize,
1797 concat!(
1798 "Offset of field: ",
1799 stringify!(spColor),
1800 "::",
1801 stringify!(g)
1802 )
1803 );
1804 assert_eq!(
1805 unsafe { &(*(::std::ptr::null::<spColor>())).b as *const _ as usize },
1806 8usize,
1807 concat!(
1808 "Offset of field: ",
1809 stringify!(spColor),
1810 "::",
1811 stringify!(b)
1812 )
1813 );
1814 assert_eq!(
1815 unsafe { &(*(::std::ptr::null::<spColor>())).a as *const _ as usize },
1816 12usize,
1817 concat!(
1818 "Offset of field: ",
1819 stringify!(spColor),
1820 "::",
1821 stringify!(a)
1822 )
1823 );
1824}
1825extern "C" {
1826 pub fn spColor_create() -> *mut spColor;
1827}
1828extern "C" {
1829 pub fn spColor_dispose(self_: *mut spColor);
1830}
1831extern "C" {
1832 pub fn spColor_setFromFloats(color: *mut spColor, r: f32, g: f32, b: f32, a: f32);
1833}
1834extern "C" {
1835 pub fn spColor_setFromColor(color: *mut spColor, otherColor: *mut spColor);
1836}
1837extern "C" {
1838 pub fn spColor_addFloats(color: *mut spColor, r: f32, g: f32, b: f32, a: f32);
1839}
1840extern "C" {
1841 pub fn spColor_addColor(color: *mut spColor, otherColor: *mut spColor);
1842}
1843extern "C" {
1844 pub fn spColor_clamp(color: *mut spColor);
1845}
1846pub const spBlendMode_SP_BLEND_MODE_NORMAL: spBlendMode = 0;
1847pub const spBlendMode_SP_BLEND_MODE_ADDITIVE: spBlendMode = 1;
1848pub const spBlendMode_SP_BLEND_MODE_MULTIPLY: spBlendMode = 2;
1849pub const spBlendMode_SP_BLEND_MODE_SCREEN: spBlendMode = 3;
1850pub type spBlendMode = u32;
1851#[repr(C)]
1852#[derive(Debug, Copy, Clone)]
1853pub struct spSlotData {
1854 pub index: ::std::os::raw::c_int,
1855 pub name: *const ::std::os::raw::c_char,
1856 pub boneData: *const spBoneData,
1857 pub attachmentName: *const ::std::os::raw::c_char,
1858 pub color: spColor,
1859 pub darkColor: *mut spColor,
1860 pub blendMode: spBlendMode,
1861}
1862#[test]
1863fn bindgen_test_layout_spSlotData() {
1864 assert_eq!(
1865 ::std::mem::size_of::<spSlotData>(),
1866 64usize,
1867 concat!("Size of: ", stringify!(spSlotData))
1868 );
1869 assert_eq!(
1870 ::std::mem::align_of::<spSlotData>(),
1871 8usize,
1872 concat!("Alignment of ", stringify!(spSlotData))
1873 );
1874 assert_eq!(
1875 unsafe { &(*(::std::ptr::null::<spSlotData>())).index as *const _ as usize },
1876 0usize,
1877 concat!(
1878 "Offset of field: ",
1879 stringify!(spSlotData),
1880 "::",
1881 stringify!(index)
1882 )
1883 );
1884 assert_eq!(
1885 unsafe { &(*(::std::ptr::null::<spSlotData>())).name as *const _ as usize },
1886 8usize,
1887 concat!(
1888 "Offset of field: ",
1889 stringify!(spSlotData),
1890 "::",
1891 stringify!(name)
1892 )
1893 );
1894 assert_eq!(
1895 unsafe { &(*(::std::ptr::null::<spSlotData>())).boneData as *const _ as usize },
1896 16usize,
1897 concat!(
1898 "Offset of field: ",
1899 stringify!(spSlotData),
1900 "::",
1901 stringify!(boneData)
1902 )
1903 );
1904 assert_eq!(
1905 unsafe { &(*(::std::ptr::null::<spSlotData>())).attachmentName as *const _ as usize },
1906 24usize,
1907 concat!(
1908 "Offset of field: ",
1909 stringify!(spSlotData),
1910 "::",
1911 stringify!(attachmentName)
1912 )
1913 );
1914 assert_eq!(
1915 unsafe { &(*(::std::ptr::null::<spSlotData>())).color as *const _ as usize },
1916 32usize,
1917 concat!(
1918 "Offset of field: ",
1919 stringify!(spSlotData),
1920 "::",
1921 stringify!(color)
1922 )
1923 );
1924 assert_eq!(
1925 unsafe { &(*(::std::ptr::null::<spSlotData>())).darkColor as *const _ as usize },
1926 48usize,
1927 concat!(
1928 "Offset of field: ",
1929 stringify!(spSlotData),
1930 "::",
1931 stringify!(darkColor)
1932 )
1933 );
1934 assert_eq!(
1935 unsafe { &(*(::std::ptr::null::<spSlotData>())).blendMode as *const _ as usize },
1936 56usize,
1937 concat!(
1938 "Offset of field: ",
1939 stringify!(spSlotData),
1940 "::",
1941 stringify!(blendMode)
1942 )
1943 );
1944}
1945extern "C" {
1946 pub fn spSlotData_create(
1947 index: ::std::os::raw::c_int,
1948 name: *const ::std::os::raw::c_char,
1949 boneData: *mut spBoneData,
1950 ) -> *mut spSlotData;
1951}
1952extern "C" {
1953 pub fn spSlotData_dispose(self_: *mut spSlotData);
1954}
1955extern "C" {
1956 pub fn spSlotData_setAttachmentName(
1957 self_: *mut spSlotData,
1958 attachmentName: *const ::std::os::raw::c_char,
1959 );
1960}
1961#[repr(C)]
1962#[derive(Debug, Copy, Clone)]
1963pub struct spIkConstraintData {
1964 pub name: *const ::std::os::raw::c_char,
1965 pub order: ::std::os::raw::c_int,
1966 pub skinRequired: ::std::os::raw::c_int,
1967 pub bonesCount: ::std::os::raw::c_int,
1968 pub bones: *mut *mut spBoneData,
1969 pub target: *mut spBoneData,
1970 pub bendDirection: ::std::os::raw::c_int,
1971 pub compress: ::std::os::raw::c_int,
1972 pub stretch: ::std::os::raw::c_int,
1973 pub uniform: ::std::os::raw::c_int,
1974 pub mix: f32,
1975 pub softness: f32,
1976}
1977#[test]
1978fn bindgen_test_layout_spIkConstraintData() {
1979 assert_eq!(
1980 ::std::mem::size_of::<spIkConstraintData>(),
1981 64usize,
1982 concat!("Size of: ", stringify!(spIkConstraintData))
1983 );
1984 assert_eq!(
1985 ::std::mem::align_of::<spIkConstraintData>(),
1986 8usize,
1987 concat!("Alignment of ", stringify!(spIkConstraintData))
1988 );
1989 assert_eq!(
1990 unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).name as *const _ as usize },
1991 0usize,
1992 concat!(
1993 "Offset of field: ",
1994 stringify!(spIkConstraintData),
1995 "::",
1996 stringify!(name)
1997 )
1998 );
1999 assert_eq!(
2000 unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).order as *const _ as usize },
2001 8usize,
2002 concat!(
2003 "Offset of field: ",
2004 stringify!(spIkConstraintData),
2005 "::",
2006 stringify!(order)
2007 )
2008 );
2009 assert_eq!(
2010 unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).skinRequired as *const _ as usize },
2011 12usize,
2012 concat!(
2013 "Offset of field: ",
2014 stringify!(spIkConstraintData),
2015 "::",
2016 stringify!(skinRequired)
2017 )
2018 );
2019 assert_eq!(
2020 unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).bonesCount as *const _ as usize },
2021 16usize,
2022 concat!(
2023 "Offset of field: ",
2024 stringify!(spIkConstraintData),
2025 "::",
2026 stringify!(bonesCount)
2027 )
2028 );
2029 assert_eq!(
2030 unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).bones as *const _ as usize },
2031 24usize,
2032 concat!(
2033 "Offset of field: ",
2034 stringify!(spIkConstraintData),
2035 "::",
2036 stringify!(bones)
2037 )
2038 );
2039 assert_eq!(
2040 unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).target as *const _ as usize },
2041 32usize,
2042 concat!(
2043 "Offset of field: ",
2044 stringify!(spIkConstraintData),
2045 "::",
2046 stringify!(target)
2047 )
2048 );
2049 assert_eq!(
2050 unsafe {
2051 &(*(::std::ptr::null::<spIkConstraintData>())).bendDirection as *const _ as usize
2052 },
2053 40usize,
2054 concat!(
2055 "Offset of field: ",
2056 stringify!(spIkConstraintData),
2057 "::",
2058 stringify!(bendDirection)
2059 )
2060 );
2061 assert_eq!(
2062 unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).compress as *const _ as usize },
2063 44usize,
2064 concat!(
2065 "Offset of field: ",
2066 stringify!(spIkConstraintData),
2067 "::",
2068 stringify!(compress)
2069 )
2070 );
2071 assert_eq!(
2072 unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).stretch as *const _ as usize },
2073 48usize,
2074 concat!(
2075 "Offset of field: ",
2076 stringify!(spIkConstraintData),
2077 "::",
2078 stringify!(stretch)
2079 )
2080 );
2081 assert_eq!(
2082 unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).uniform as *const _ as usize },
2083 52usize,
2084 concat!(
2085 "Offset of field: ",
2086 stringify!(spIkConstraintData),
2087 "::",
2088 stringify!(uniform)
2089 )
2090 );
2091 assert_eq!(
2092 unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).mix as *const _ as usize },
2093 56usize,
2094 concat!(
2095 "Offset of field: ",
2096 stringify!(spIkConstraintData),
2097 "::",
2098 stringify!(mix)
2099 )
2100 );
2101 assert_eq!(
2102 unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).softness as *const _ as usize },
2103 60usize,
2104 concat!(
2105 "Offset of field: ",
2106 stringify!(spIkConstraintData),
2107 "::",
2108 stringify!(softness)
2109 )
2110 );
2111}
2112extern "C" {
2113 pub fn spIkConstraintData_create(
2114 name: *const ::std::os::raw::c_char,
2115 ) -> *mut spIkConstraintData;
2116}
2117extern "C" {
2118 pub fn spIkConstraintData_dispose(self_: *mut spIkConstraintData);
2119}
2120#[repr(C)]
2121#[derive(Debug, Copy, Clone)]
2122pub struct spTransformConstraintData {
2123 pub name: *const ::std::os::raw::c_char,
2124 pub order: ::std::os::raw::c_int,
2125 pub skinRequired: ::std::os::raw::c_int,
2126 pub bonesCount: ::std::os::raw::c_int,
2127 pub bones: *mut *mut spBoneData,
2128 pub target: *mut spBoneData,
2129 pub rotateMix: f32,
2130 pub translateMix: f32,
2131 pub scaleMix: f32,
2132 pub shearMix: f32,
2133 pub offsetRotation: f32,
2134 pub offsetX: f32,
2135 pub offsetY: f32,
2136 pub offsetScaleX: f32,
2137 pub offsetScaleY: f32,
2138 pub offsetShearY: f32,
2139 pub relative: ::std::os::raw::c_int,
2140 pub local: ::std::os::raw::c_int,
2141}
2142#[test]
2143fn bindgen_test_layout_spTransformConstraintData() {
2144 assert_eq!(
2145 ::std::mem::size_of::<spTransformConstraintData>(),
2146 88usize,
2147 concat!("Size of: ", stringify!(spTransformConstraintData))
2148 );
2149 assert_eq!(
2150 ::std::mem::align_of::<spTransformConstraintData>(),
2151 8usize,
2152 concat!("Alignment of ", stringify!(spTransformConstraintData))
2153 );
2154 assert_eq!(
2155 unsafe { &(*(::std::ptr::null::<spTransformConstraintData>())).name as *const _ as usize },
2156 0usize,
2157 concat!(
2158 "Offset of field: ",
2159 stringify!(spTransformConstraintData),
2160 "::",
2161 stringify!(name)
2162 )
2163 );
2164 assert_eq!(
2165 unsafe { &(*(::std::ptr::null::<spTransformConstraintData>())).order as *const _ as usize },
2166 8usize,
2167 concat!(
2168 "Offset of field: ",
2169 stringify!(spTransformConstraintData),
2170 "::",
2171 stringify!(order)
2172 )
2173 );
2174 assert_eq!(
2175 unsafe {
2176 &(*(::std::ptr::null::<spTransformConstraintData>())).skinRequired as *const _ as usize
2177 },
2178 12usize,
2179 concat!(
2180 "Offset of field: ",
2181 stringify!(spTransformConstraintData),
2182 "::",
2183 stringify!(skinRequired)
2184 )
2185 );
2186 assert_eq!(
2187 unsafe {
2188 &(*(::std::ptr::null::<spTransformConstraintData>())).bonesCount as *const _ as usize
2189 },
2190 16usize,
2191 concat!(
2192 "Offset of field: ",
2193 stringify!(spTransformConstraintData),
2194 "::",
2195 stringify!(bonesCount)
2196 )
2197 );
2198 assert_eq!(
2199 unsafe { &(*(::std::ptr::null::<spTransformConstraintData>())).bones as *const _ as usize },
2200 24usize,
2201 concat!(
2202 "Offset of field: ",
2203 stringify!(spTransformConstraintData),
2204 "::",
2205 stringify!(bones)
2206 )
2207 );
2208 assert_eq!(
2209 unsafe {
2210 &(*(::std::ptr::null::<spTransformConstraintData>())).target as *const _ as usize
2211 },
2212 32usize,
2213 concat!(
2214 "Offset of field: ",
2215 stringify!(spTransformConstraintData),
2216 "::",
2217 stringify!(target)
2218 )
2219 );
2220 assert_eq!(
2221 unsafe {
2222 &(*(::std::ptr::null::<spTransformConstraintData>())).rotateMix as *const _ as usize
2223 },
2224 40usize,
2225 concat!(
2226 "Offset of field: ",
2227 stringify!(spTransformConstraintData),
2228 "::",
2229 stringify!(rotateMix)
2230 )
2231 );
2232 assert_eq!(
2233 unsafe {
2234 &(*(::std::ptr::null::<spTransformConstraintData>())).translateMix as *const _ as usize
2235 },
2236 44usize,
2237 concat!(
2238 "Offset of field: ",
2239 stringify!(spTransformConstraintData),
2240 "::",
2241 stringify!(translateMix)
2242 )
2243 );
2244 assert_eq!(
2245 unsafe {
2246 &(*(::std::ptr::null::<spTransformConstraintData>())).scaleMix as *const _ as usize
2247 },
2248 48usize,
2249 concat!(
2250 "Offset of field: ",
2251 stringify!(spTransformConstraintData),
2252 "::",
2253 stringify!(scaleMix)
2254 )
2255 );
2256 assert_eq!(
2257 unsafe {
2258 &(*(::std::ptr::null::<spTransformConstraintData>())).shearMix as *const _ as usize
2259 },
2260 52usize,
2261 concat!(
2262 "Offset of field: ",
2263 stringify!(spTransformConstraintData),
2264 "::",
2265 stringify!(shearMix)
2266 )
2267 );
2268 assert_eq!(
2269 unsafe {
2270 &(*(::std::ptr::null::<spTransformConstraintData>())).offsetRotation as *const _
2271 as usize
2272 },
2273 56usize,
2274 concat!(
2275 "Offset of field: ",
2276 stringify!(spTransformConstraintData),
2277 "::",
2278 stringify!(offsetRotation)
2279 )
2280 );
2281 assert_eq!(
2282 unsafe {
2283 &(*(::std::ptr::null::<spTransformConstraintData>())).offsetX as *const _ as usize
2284 },
2285 60usize,
2286 concat!(
2287 "Offset of field: ",
2288 stringify!(spTransformConstraintData),
2289 "::",
2290 stringify!(offsetX)
2291 )
2292 );
2293 assert_eq!(
2294 unsafe {
2295 &(*(::std::ptr::null::<spTransformConstraintData>())).offsetY as *const _ as usize
2296 },
2297 64usize,
2298 concat!(
2299 "Offset of field: ",
2300 stringify!(spTransformConstraintData),
2301 "::",
2302 stringify!(offsetY)
2303 )
2304 );
2305 assert_eq!(
2306 unsafe {
2307 &(*(::std::ptr::null::<spTransformConstraintData>())).offsetScaleX as *const _ as usize
2308 },
2309 68usize,
2310 concat!(
2311 "Offset of field: ",
2312 stringify!(spTransformConstraintData),
2313 "::",
2314 stringify!(offsetScaleX)
2315 )
2316 );
2317 assert_eq!(
2318 unsafe {
2319 &(*(::std::ptr::null::<spTransformConstraintData>())).offsetScaleY as *const _ as usize
2320 },
2321 72usize,
2322 concat!(
2323 "Offset of field: ",
2324 stringify!(spTransformConstraintData),
2325 "::",
2326 stringify!(offsetScaleY)
2327 )
2328 );
2329 assert_eq!(
2330 unsafe {
2331 &(*(::std::ptr::null::<spTransformConstraintData>())).offsetShearY as *const _ as usize
2332 },
2333 76usize,
2334 concat!(
2335 "Offset of field: ",
2336 stringify!(spTransformConstraintData),
2337 "::",
2338 stringify!(offsetShearY)
2339 )
2340 );
2341 assert_eq!(
2342 unsafe {
2343 &(*(::std::ptr::null::<spTransformConstraintData>())).relative as *const _ as usize
2344 },
2345 80usize,
2346 concat!(
2347 "Offset of field: ",
2348 stringify!(spTransformConstraintData),
2349 "::",
2350 stringify!(relative)
2351 )
2352 );
2353 assert_eq!(
2354 unsafe { &(*(::std::ptr::null::<spTransformConstraintData>())).local as *const _ as usize },
2355 84usize,
2356 concat!(
2357 "Offset of field: ",
2358 stringify!(spTransformConstraintData),
2359 "::",
2360 stringify!(local)
2361 )
2362 );
2363}
2364extern "C" {
2365 pub fn spTransformConstraintData_create(
2366 name: *const ::std::os::raw::c_char,
2367 ) -> *mut spTransformConstraintData;
2368}
2369extern "C" {
2370 pub fn spTransformConstraintData_dispose(self_: *mut spTransformConstraintData);
2371}
2372pub const spPositionMode_SP_POSITION_MODE_FIXED: spPositionMode = 0;
2373pub const spPositionMode_SP_POSITION_MODE_PERCENT: spPositionMode = 1;
2374pub type spPositionMode = u32;
2375pub const spSpacingMode_SP_SPACING_MODE_LENGTH: spSpacingMode = 0;
2376pub const spSpacingMode_SP_SPACING_MODE_FIXED: spSpacingMode = 1;
2377pub const spSpacingMode_SP_SPACING_MODE_PERCENT: spSpacingMode = 2;
2378pub type spSpacingMode = u32;
2379pub const spRotateMode_SP_ROTATE_MODE_TANGENT: spRotateMode = 0;
2380pub const spRotateMode_SP_ROTATE_MODE_CHAIN: spRotateMode = 1;
2381pub const spRotateMode_SP_ROTATE_MODE_CHAIN_SCALE: spRotateMode = 2;
2382pub type spRotateMode = u32;
2383#[repr(C)]
2384#[derive(Debug, Copy, Clone)]
2385pub struct spPathConstraintData {
2386 pub name: *const ::std::os::raw::c_char,
2387 pub order: ::std::os::raw::c_int,
2388 pub skinRequired: ::std::os::raw::c_int,
2389 pub bonesCount: ::std::os::raw::c_int,
2390 pub bones: *mut *mut spBoneData,
2391 pub target: *mut spSlotData,
2392 pub positionMode: spPositionMode,
2393 pub spacingMode: spSpacingMode,
2394 pub rotateMode: spRotateMode,
2395 pub offsetRotation: f32,
2396 pub position: f32,
2397 pub spacing: f32,
2398 pub rotateMix: f32,
2399 pub translateMix: f32,
2400}
2401#[test]
2402fn bindgen_test_layout_spPathConstraintData() {
2403 assert_eq!(
2404 ::std::mem::size_of::<spPathConstraintData>(),
2405 72usize,
2406 concat!("Size of: ", stringify!(spPathConstraintData))
2407 );
2408 assert_eq!(
2409 ::std::mem::align_of::<spPathConstraintData>(),
2410 8usize,
2411 concat!("Alignment of ", stringify!(spPathConstraintData))
2412 );
2413 assert_eq!(
2414 unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).name as *const _ as usize },
2415 0usize,
2416 concat!(
2417 "Offset of field: ",
2418 stringify!(spPathConstraintData),
2419 "::",
2420 stringify!(name)
2421 )
2422 );
2423 assert_eq!(
2424 unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).order as *const _ as usize },
2425 8usize,
2426 concat!(
2427 "Offset of field: ",
2428 stringify!(spPathConstraintData),
2429 "::",
2430 stringify!(order)
2431 )
2432 );
2433 assert_eq!(
2434 unsafe {
2435 &(*(::std::ptr::null::<spPathConstraintData>())).skinRequired as *const _ as usize
2436 },
2437 12usize,
2438 concat!(
2439 "Offset of field: ",
2440 stringify!(spPathConstraintData),
2441 "::",
2442 stringify!(skinRequired)
2443 )
2444 );
2445 assert_eq!(
2446 unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).bonesCount as *const _ as usize },
2447 16usize,
2448 concat!(
2449 "Offset of field: ",
2450 stringify!(spPathConstraintData),
2451 "::",
2452 stringify!(bonesCount)
2453 )
2454 );
2455 assert_eq!(
2456 unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).bones as *const _ as usize },
2457 24usize,
2458 concat!(
2459 "Offset of field: ",
2460 stringify!(spPathConstraintData),
2461 "::",
2462 stringify!(bones)
2463 )
2464 );
2465 assert_eq!(
2466 unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).target as *const _ as usize },
2467 32usize,
2468 concat!(
2469 "Offset of field: ",
2470 stringify!(spPathConstraintData),
2471 "::",
2472 stringify!(target)
2473 )
2474 );
2475 assert_eq!(
2476 unsafe {
2477 &(*(::std::ptr::null::<spPathConstraintData>())).positionMode as *const _ as usize
2478 },
2479 40usize,
2480 concat!(
2481 "Offset of field: ",
2482 stringify!(spPathConstraintData),
2483 "::",
2484 stringify!(positionMode)
2485 )
2486 );
2487 assert_eq!(
2488 unsafe {
2489 &(*(::std::ptr::null::<spPathConstraintData>())).spacingMode as *const _ as usize
2490 },
2491 44usize,
2492 concat!(
2493 "Offset of field: ",
2494 stringify!(spPathConstraintData),
2495 "::",
2496 stringify!(spacingMode)
2497 )
2498 );
2499 assert_eq!(
2500 unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).rotateMode as *const _ as usize },
2501 48usize,
2502 concat!(
2503 "Offset of field: ",
2504 stringify!(spPathConstraintData),
2505 "::",
2506 stringify!(rotateMode)
2507 )
2508 );
2509 assert_eq!(
2510 unsafe {
2511 &(*(::std::ptr::null::<spPathConstraintData>())).offsetRotation as *const _ as usize
2512 },
2513 52usize,
2514 concat!(
2515 "Offset of field: ",
2516 stringify!(spPathConstraintData),
2517 "::",
2518 stringify!(offsetRotation)
2519 )
2520 );
2521 assert_eq!(
2522 unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).position as *const _ as usize },
2523 56usize,
2524 concat!(
2525 "Offset of field: ",
2526 stringify!(spPathConstraintData),
2527 "::",
2528 stringify!(position)
2529 )
2530 );
2531 assert_eq!(
2532 unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).spacing as *const _ as usize },
2533 60usize,
2534 concat!(
2535 "Offset of field: ",
2536 stringify!(spPathConstraintData),
2537 "::",
2538 stringify!(spacing)
2539 )
2540 );
2541 assert_eq!(
2542 unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).rotateMix as *const _ as usize },
2543 64usize,
2544 concat!(
2545 "Offset of field: ",
2546 stringify!(spPathConstraintData),
2547 "::",
2548 stringify!(rotateMix)
2549 )
2550 );
2551 assert_eq!(
2552 unsafe {
2553 &(*(::std::ptr::null::<spPathConstraintData>())).translateMix as *const _ as usize
2554 },
2555 68usize,
2556 concat!(
2557 "Offset of field: ",
2558 stringify!(spPathConstraintData),
2559 "::",
2560 stringify!(translateMix)
2561 )
2562 );
2563}
2564extern "C" {
2565 pub fn spPathConstraintData_create(
2566 name: *const ::std::os::raw::c_char,
2567 ) -> *mut spPathConstraintData;
2568}
2569extern "C" {
2570 pub fn spPathConstraintData_dispose(self_: *mut spPathConstraintData);
2571}
2572#[repr(C)]
2573#[derive(Debug, Copy, Clone)]
2574pub struct spFloatArray {
2575 pub size: ::std::os::raw::c_int,
2576 pub capacity: ::std::os::raw::c_int,
2577 pub items: *mut f32,
2578}
2579#[test]
2580fn bindgen_test_layout_spFloatArray() {
2581 assert_eq!(
2582 ::std::mem::size_of::<spFloatArray>(),
2583 16usize,
2584 concat!("Size of: ", stringify!(spFloatArray))
2585 );
2586 assert_eq!(
2587 ::std::mem::align_of::<spFloatArray>(),
2588 8usize,
2589 concat!("Alignment of ", stringify!(spFloatArray))
2590 );
2591 assert_eq!(
2592 unsafe { &(*(::std::ptr::null::<spFloatArray>())).size as *const _ as usize },
2593 0usize,
2594 concat!(
2595 "Offset of field: ",
2596 stringify!(spFloatArray),
2597 "::",
2598 stringify!(size)
2599 )
2600 );
2601 assert_eq!(
2602 unsafe { &(*(::std::ptr::null::<spFloatArray>())).capacity as *const _ as usize },
2603 4usize,
2604 concat!(
2605 "Offset of field: ",
2606 stringify!(spFloatArray),
2607 "::",
2608 stringify!(capacity)
2609 )
2610 );
2611 assert_eq!(
2612 unsafe { &(*(::std::ptr::null::<spFloatArray>())).items as *const _ as usize },
2613 8usize,
2614 concat!(
2615 "Offset of field: ",
2616 stringify!(spFloatArray),
2617 "::",
2618 stringify!(items)
2619 )
2620 );
2621}
2622extern "C" {
2623 pub fn spFloatArray_create(initialCapacity: ::std::os::raw::c_int) -> *mut spFloatArray;
2624}
2625extern "C" {
2626 pub fn spFloatArray_dispose(self_: *mut spFloatArray);
2627}
2628extern "C" {
2629 pub fn spFloatArray_clear(self_: *mut spFloatArray);
2630}
2631extern "C" {
2632 pub fn spFloatArray_setSize(
2633 self_: *mut spFloatArray,
2634 newSize: ::std::os::raw::c_int,
2635 ) -> *mut spFloatArray;
2636}
2637extern "C" {
2638 pub fn spFloatArray_ensureCapacity(
2639 self_: *mut spFloatArray,
2640 newCapacity: ::std::os::raw::c_int,
2641 );
2642}
2643extern "C" {
2644 pub fn spFloatArray_add(self_: *mut spFloatArray, value: f32);
2645}
2646extern "C" {
2647 pub fn spFloatArray_addAll(self_: *mut spFloatArray, other: *mut spFloatArray);
2648}
2649extern "C" {
2650 pub fn spFloatArray_addAllValues(
2651 self_: *mut spFloatArray,
2652 values: *mut f32,
2653 offset: ::std::os::raw::c_int,
2654 count: ::std::os::raw::c_int,
2655 );
2656}
2657extern "C" {
2658 pub fn spFloatArray_removeAt(self_: *mut spFloatArray, index: ::std::os::raw::c_int);
2659}
2660extern "C" {
2661 pub fn spFloatArray_contains(self_: *mut spFloatArray, value: f32) -> ::std::os::raw::c_int;
2662}
2663extern "C" {
2664 pub fn spFloatArray_pop(self_: *mut spFloatArray) -> f32;
2665}
2666extern "C" {
2667 pub fn spFloatArray_peek(self_: *mut spFloatArray) -> f32;
2668}
2669#[repr(C)]
2670#[derive(Debug, Copy, Clone)]
2671pub struct spIntArray {
2672 pub size: ::std::os::raw::c_int,
2673 pub capacity: ::std::os::raw::c_int,
2674 pub items: *mut ::std::os::raw::c_int,
2675}
2676#[test]
2677fn bindgen_test_layout_spIntArray() {
2678 assert_eq!(
2679 ::std::mem::size_of::<spIntArray>(),
2680 16usize,
2681 concat!("Size of: ", stringify!(spIntArray))
2682 );
2683 assert_eq!(
2684 ::std::mem::align_of::<spIntArray>(),
2685 8usize,
2686 concat!("Alignment of ", stringify!(spIntArray))
2687 );
2688 assert_eq!(
2689 unsafe { &(*(::std::ptr::null::<spIntArray>())).size as *const _ as usize },
2690 0usize,
2691 concat!(
2692 "Offset of field: ",
2693 stringify!(spIntArray),
2694 "::",
2695 stringify!(size)
2696 )
2697 );
2698 assert_eq!(
2699 unsafe { &(*(::std::ptr::null::<spIntArray>())).capacity as *const _ as usize },
2700 4usize,
2701 concat!(
2702 "Offset of field: ",
2703 stringify!(spIntArray),
2704 "::",
2705 stringify!(capacity)
2706 )
2707 );
2708 assert_eq!(
2709 unsafe { &(*(::std::ptr::null::<spIntArray>())).items as *const _ as usize },
2710 8usize,
2711 concat!(
2712 "Offset of field: ",
2713 stringify!(spIntArray),
2714 "::",
2715 stringify!(items)
2716 )
2717 );
2718}
2719extern "C" {
2720 pub fn spIntArray_create(initialCapacity: ::std::os::raw::c_int) -> *mut spIntArray;
2721}
2722extern "C" {
2723 pub fn spIntArray_dispose(self_: *mut spIntArray);
2724}
2725extern "C" {
2726 pub fn spIntArray_clear(self_: *mut spIntArray);
2727}
2728extern "C" {
2729 pub fn spIntArray_setSize(
2730 self_: *mut spIntArray,
2731 newSize: ::std::os::raw::c_int,
2732 ) -> *mut spIntArray;
2733}
2734extern "C" {
2735 pub fn spIntArray_ensureCapacity(self_: *mut spIntArray, newCapacity: ::std::os::raw::c_int);
2736}
2737extern "C" {
2738 pub fn spIntArray_add(self_: *mut spIntArray, value: ::std::os::raw::c_int);
2739}
2740extern "C" {
2741 pub fn spIntArray_addAll(self_: *mut spIntArray, other: *mut spIntArray);
2742}
2743extern "C" {
2744 pub fn spIntArray_addAllValues(
2745 self_: *mut spIntArray,
2746 values: *mut ::std::os::raw::c_int,
2747 offset: ::std::os::raw::c_int,
2748 count: ::std::os::raw::c_int,
2749 );
2750}
2751extern "C" {
2752 pub fn spIntArray_removeAt(self_: *mut spIntArray, index: ::std::os::raw::c_int);
2753}
2754extern "C" {
2755 pub fn spIntArray_contains(
2756 self_: *mut spIntArray,
2757 value: ::std::os::raw::c_int,
2758 ) -> ::std::os::raw::c_int;
2759}
2760extern "C" {
2761 pub fn spIntArray_pop(self_: *mut spIntArray) -> ::std::os::raw::c_int;
2762}
2763extern "C" {
2764 pub fn spIntArray_peek(self_: *mut spIntArray) -> ::std::os::raw::c_int;
2765}
2766#[repr(C)]
2767#[derive(Debug, Copy, Clone)]
2768pub struct spShortArray {
2769 pub size: ::std::os::raw::c_int,
2770 pub capacity: ::std::os::raw::c_int,
2771 pub items: *mut ::std::os::raw::c_short,
2772}
2773#[test]
2774fn bindgen_test_layout_spShortArray() {
2775 assert_eq!(
2776 ::std::mem::size_of::<spShortArray>(),
2777 16usize,
2778 concat!("Size of: ", stringify!(spShortArray))
2779 );
2780 assert_eq!(
2781 ::std::mem::align_of::<spShortArray>(),
2782 8usize,
2783 concat!("Alignment of ", stringify!(spShortArray))
2784 );
2785 assert_eq!(
2786 unsafe { &(*(::std::ptr::null::<spShortArray>())).size as *const _ as usize },
2787 0usize,
2788 concat!(
2789 "Offset of field: ",
2790 stringify!(spShortArray),
2791 "::",
2792 stringify!(size)
2793 )
2794 );
2795 assert_eq!(
2796 unsafe { &(*(::std::ptr::null::<spShortArray>())).capacity as *const _ as usize },
2797 4usize,
2798 concat!(
2799 "Offset of field: ",
2800 stringify!(spShortArray),
2801 "::",
2802 stringify!(capacity)
2803 )
2804 );
2805 assert_eq!(
2806 unsafe { &(*(::std::ptr::null::<spShortArray>())).items as *const _ as usize },
2807 8usize,
2808 concat!(
2809 "Offset of field: ",
2810 stringify!(spShortArray),
2811 "::",
2812 stringify!(items)
2813 )
2814 );
2815}
2816extern "C" {
2817 pub fn spShortArray_create(initialCapacity: ::std::os::raw::c_int) -> *mut spShortArray;
2818}
2819extern "C" {
2820 pub fn spShortArray_dispose(self_: *mut spShortArray);
2821}
2822extern "C" {
2823 pub fn spShortArray_clear(self_: *mut spShortArray);
2824}
2825extern "C" {
2826 pub fn spShortArray_setSize(
2827 self_: *mut spShortArray,
2828 newSize: ::std::os::raw::c_int,
2829 ) -> *mut spShortArray;
2830}
2831extern "C" {
2832 pub fn spShortArray_ensureCapacity(
2833 self_: *mut spShortArray,
2834 newCapacity: ::std::os::raw::c_int,
2835 );
2836}
2837extern "C" {
2838 pub fn spShortArray_add(self_: *mut spShortArray, value: ::std::os::raw::c_short);
2839}
2840extern "C" {
2841 pub fn spShortArray_addAll(self_: *mut spShortArray, other: *mut spShortArray);
2842}
2843extern "C" {
2844 pub fn spShortArray_addAllValues(
2845 self_: *mut spShortArray,
2846 values: *mut ::std::os::raw::c_short,
2847 offset: ::std::os::raw::c_int,
2848 count: ::std::os::raw::c_int,
2849 );
2850}
2851extern "C" {
2852 pub fn spShortArray_removeAt(self_: *mut spShortArray, index: ::std::os::raw::c_int);
2853}
2854extern "C" {
2855 pub fn spShortArray_contains(
2856 self_: *mut spShortArray,
2857 value: ::std::os::raw::c_short,
2858 ) -> ::std::os::raw::c_int;
2859}
2860extern "C" {
2861 pub fn spShortArray_pop(self_: *mut spShortArray) -> ::std::os::raw::c_short;
2862}
2863extern "C" {
2864 pub fn spShortArray_peek(self_: *mut spShortArray) -> ::std::os::raw::c_short;
2865}
2866#[repr(C)]
2867#[derive(Debug, Copy, Clone)]
2868pub struct spUnsignedShortArray {
2869 pub size: ::std::os::raw::c_int,
2870 pub capacity: ::std::os::raw::c_int,
2871 pub items: *mut ::std::os::raw::c_ushort,
2872}
2873#[test]
2874fn bindgen_test_layout_spUnsignedShortArray() {
2875 assert_eq!(
2876 ::std::mem::size_of::<spUnsignedShortArray>(),
2877 16usize,
2878 concat!("Size of: ", stringify!(spUnsignedShortArray))
2879 );
2880 assert_eq!(
2881 ::std::mem::align_of::<spUnsignedShortArray>(),
2882 8usize,
2883 concat!("Alignment of ", stringify!(spUnsignedShortArray))
2884 );
2885 assert_eq!(
2886 unsafe { &(*(::std::ptr::null::<spUnsignedShortArray>())).size as *const _ as usize },
2887 0usize,
2888 concat!(
2889 "Offset of field: ",
2890 stringify!(spUnsignedShortArray),
2891 "::",
2892 stringify!(size)
2893 )
2894 );
2895 assert_eq!(
2896 unsafe { &(*(::std::ptr::null::<spUnsignedShortArray>())).capacity as *const _ as usize },
2897 4usize,
2898 concat!(
2899 "Offset of field: ",
2900 stringify!(spUnsignedShortArray),
2901 "::",
2902 stringify!(capacity)
2903 )
2904 );
2905 assert_eq!(
2906 unsafe { &(*(::std::ptr::null::<spUnsignedShortArray>())).items as *const _ as usize },
2907 8usize,
2908 concat!(
2909 "Offset of field: ",
2910 stringify!(spUnsignedShortArray),
2911 "::",
2912 stringify!(items)
2913 )
2914 );
2915}
2916extern "C" {
2917 pub fn spUnsignedShortArray_create(
2918 initialCapacity: ::std::os::raw::c_int,
2919 ) -> *mut spUnsignedShortArray;
2920}
2921extern "C" {
2922 pub fn spUnsignedShortArray_dispose(self_: *mut spUnsignedShortArray);
2923}
2924extern "C" {
2925 pub fn spUnsignedShortArray_clear(self_: *mut spUnsignedShortArray);
2926}
2927extern "C" {
2928 pub fn spUnsignedShortArray_setSize(
2929 self_: *mut spUnsignedShortArray,
2930 newSize: ::std::os::raw::c_int,
2931 ) -> *mut spUnsignedShortArray;
2932}
2933extern "C" {
2934 pub fn spUnsignedShortArray_ensureCapacity(
2935 self_: *mut spUnsignedShortArray,
2936 newCapacity: ::std::os::raw::c_int,
2937 );
2938}
2939extern "C" {
2940 pub fn spUnsignedShortArray_add(
2941 self_: *mut spUnsignedShortArray,
2942 value: ::std::os::raw::c_ushort,
2943 );
2944}
2945extern "C" {
2946 pub fn spUnsignedShortArray_addAll(
2947 self_: *mut spUnsignedShortArray,
2948 other: *mut spUnsignedShortArray,
2949 );
2950}
2951extern "C" {
2952 pub fn spUnsignedShortArray_addAllValues(
2953 self_: *mut spUnsignedShortArray,
2954 values: *mut ::std::os::raw::c_ushort,
2955 offset: ::std::os::raw::c_int,
2956 count: ::std::os::raw::c_int,
2957 );
2958}
2959extern "C" {
2960 pub fn spUnsignedShortArray_removeAt(
2961 self_: *mut spUnsignedShortArray,
2962 index: ::std::os::raw::c_int,
2963 );
2964}
2965extern "C" {
2966 pub fn spUnsignedShortArray_contains(
2967 self_: *mut spUnsignedShortArray,
2968 value: ::std::os::raw::c_ushort,
2969 ) -> ::std::os::raw::c_int;
2970}
2971extern "C" {
2972 pub fn spUnsignedShortArray_pop(self_: *mut spUnsignedShortArray) -> ::std::os::raw::c_ushort;
2973}
2974extern "C" {
2975 pub fn spUnsignedShortArray_peek(self_: *mut spUnsignedShortArray) -> ::std::os::raw::c_ushort;
2976}
2977#[repr(C)]
2978#[derive(Debug, Copy, Clone)]
2979pub struct spArrayFloatArray {
2980 pub size: ::std::os::raw::c_int,
2981 pub capacity: ::std::os::raw::c_int,
2982 pub items: *mut *mut spFloatArray,
2983}
2984#[test]
2985fn bindgen_test_layout_spArrayFloatArray() {
2986 assert_eq!(
2987 ::std::mem::size_of::<spArrayFloatArray>(),
2988 16usize,
2989 concat!("Size of: ", stringify!(spArrayFloatArray))
2990 );
2991 assert_eq!(
2992 ::std::mem::align_of::<spArrayFloatArray>(),
2993 8usize,
2994 concat!("Alignment of ", stringify!(spArrayFloatArray))
2995 );
2996 assert_eq!(
2997 unsafe { &(*(::std::ptr::null::<spArrayFloatArray>())).size as *const _ as usize },
2998 0usize,
2999 concat!(
3000 "Offset of field: ",
3001 stringify!(spArrayFloatArray),
3002 "::",
3003 stringify!(size)
3004 )
3005 );
3006 assert_eq!(
3007 unsafe { &(*(::std::ptr::null::<spArrayFloatArray>())).capacity as *const _ as usize },
3008 4usize,
3009 concat!(
3010 "Offset of field: ",
3011 stringify!(spArrayFloatArray),
3012 "::",
3013 stringify!(capacity)
3014 )
3015 );
3016 assert_eq!(
3017 unsafe { &(*(::std::ptr::null::<spArrayFloatArray>())).items as *const _ as usize },
3018 8usize,
3019 concat!(
3020 "Offset of field: ",
3021 stringify!(spArrayFloatArray),
3022 "::",
3023 stringify!(items)
3024 )
3025 );
3026}
3027extern "C" {
3028 pub fn spArrayFloatArray_create(
3029 initialCapacity: ::std::os::raw::c_int,
3030 ) -> *mut spArrayFloatArray;
3031}
3032extern "C" {
3033 pub fn spArrayFloatArray_dispose(self_: *mut spArrayFloatArray);
3034}
3035extern "C" {
3036 pub fn spArrayFloatArray_clear(self_: *mut spArrayFloatArray);
3037}
3038extern "C" {
3039 pub fn spArrayFloatArray_setSize(
3040 self_: *mut spArrayFloatArray,
3041 newSize: ::std::os::raw::c_int,
3042 ) -> *mut spArrayFloatArray;
3043}
3044extern "C" {
3045 pub fn spArrayFloatArray_ensureCapacity(
3046 self_: *mut spArrayFloatArray,
3047 newCapacity: ::std::os::raw::c_int,
3048 );
3049}
3050extern "C" {
3051 pub fn spArrayFloatArray_add(self_: *mut spArrayFloatArray, value: *mut spFloatArray);
3052}
3053extern "C" {
3054 pub fn spArrayFloatArray_addAll(self_: *mut spArrayFloatArray, other: *mut spArrayFloatArray);
3055}
3056extern "C" {
3057 pub fn spArrayFloatArray_addAllValues(
3058 self_: *mut spArrayFloatArray,
3059 values: *mut *mut spFloatArray,
3060 offset: ::std::os::raw::c_int,
3061 count: ::std::os::raw::c_int,
3062 );
3063}
3064extern "C" {
3065 pub fn spArrayFloatArray_removeAt(self_: *mut spArrayFloatArray, index: ::std::os::raw::c_int);
3066}
3067extern "C" {
3068 pub fn spArrayFloatArray_contains(
3069 self_: *mut spArrayFloatArray,
3070 value: *mut spFloatArray,
3071 ) -> ::std::os::raw::c_int;
3072}
3073extern "C" {
3074 pub fn spArrayFloatArray_pop(self_: *mut spArrayFloatArray) -> *mut spFloatArray;
3075}
3076extern "C" {
3077 pub fn spArrayFloatArray_peek(self_: *mut spArrayFloatArray) -> *mut spFloatArray;
3078}
3079#[repr(C)]
3080#[derive(Debug, Copy, Clone)]
3081pub struct spArrayShortArray {
3082 pub size: ::std::os::raw::c_int,
3083 pub capacity: ::std::os::raw::c_int,
3084 pub items: *mut *mut spShortArray,
3085}
3086#[test]
3087fn bindgen_test_layout_spArrayShortArray() {
3088 assert_eq!(
3089 ::std::mem::size_of::<spArrayShortArray>(),
3090 16usize,
3091 concat!("Size of: ", stringify!(spArrayShortArray))
3092 );
3093 assert_eq!(
3094 ::std::mem::align_of::<spArrayShortArray>(),
3095 8usize,
3096 concat!("Alignment of ", stringify!(spArrayShortArray))
3097 );
3098 assert_eq!(
3099 unsafe { &(*(::std::ptr::null::<spArrayShortArray>())).size as *const _ as usize },
3100 0usize,
3101 concat!(
3102 "Offset of field: ",
3103 stringify!(spArrayShortArray),
3104 "::",
3105 stringify!(size)
3106 )
3107 );
3108 assert_eq!(
3109 unsafe { &(*(::std::ptr::null::<spArrayShortArray>())).capacity as *const _ as usize },
3110 4usize,
3111 concat!(
3112 "Offset of field: ",
3113 stringify!(spArrayShortArray),
3114 "::",
3115 stringify!(capacity)
3116 )
3117 );
3118 assert_eq!(
3119 unsafe { &(*(::std::ptr::null::<spArrayShortArray>())).items as *const _ as usize },
3120 8usize,
3121 concat!(
3122 "Offset of field: ",
3123 stringify!(spArrayShortArray),
3124 "::",
3125 stringify!(items)
3126 )
3127 );
3128}
3129extern "C" {
3130 pub fn spArrayShortArray_create(
3131 initialCapacity: ::std::os::raw::c_int,
3132 ) -> *mut spArrayShortArray;
3133}
3134extern "C" {
3135 pub fn spArrayShortArray_dispose(self_: *mut spArrayShortArray);
3136}
3137extern "C" {
3138 pub fn spArrayShortArray_clear(self_: *mut spArrayShortArray);
3139}
3140extern "C" {
3141 pub fn spArrayShortArray_setSize(
3142 self_: *mut spArrayShortArray,
3143 newSize: ::std::os::raw::c_int,
3144 ) -> *mut spArrayShortArray;
3145}
3146extern "C" {
3147 pub fn spArrayShortArray_ensureCapacity(
3148 self_: *mut spArrayShortArray,
3149 newCapacity: ::std::os::raw::c_int,
3150 );
3151}
3152extern "C" {
3153 pub fn spArrayShortArray_add(self_: *mut spArrayShortArray, value: *mut spShortArray);
3154}
3155extern "C" {
3156 pub fn spArrayShortArray_addAll(self_: *mut spArrayShortArray, other: *mut spArrayShortArray);
3157}
3158extern "C" {
3159 pub fn spArrayShortArray_addAllValues(
3160 self_: *mut spArrayShortArray,
3161 values: *mut *mut spShortArray,
3162 offset: ::std::os::raw::c_int,
3163 count: ::std::os::raw::c_int,
3164 );
3165}
3166extern "C" {
3167 pub fn spArrayShortArray_removeAt(self_: *mut spArrayShortArray, index: ::std::os::raw::c_int);
3168}
3169extern "C" {
3170 pub fn spArrayShortArray_contains(
3171 self_: *mut spArrayShortArray,
3172 value: *mut spShortArray,
3173 ) -> ::std::os::raw::c_int;
3174}
3175extern "C" {
3176 pub fn spArrayShortArray_pop(self_: *mut spArrayShortArray) -> *mut spShortArray;
3177}
3178extern "C" {
3179 pub fn spArrayShortArray_peek(self_: *mut spArrayShortArray) -> *mut spShortArray;
3180}
3181#[repr(C)]
3182#[derive(Debug, Copy, Clone)]
3183pub struct spBoneDataArray {
3184 pub size: ::std::os::raw::c_int,
3185 pub capacity: ::std::os::raw::c_int,
3186 pub items: *mut *mut spBoneData,
3187}
3188#[test]
3189fn bindgen_test_layout_spBoneDataArray() {
3190 assert_eq!(
3191 ::std::mem::size_of::<spBoneDataArray>(),
3192 16usize,
3193 concat!("Size of: ", stringify!(spBoneDataArray))
3194 );
3195 assert_eq!(
3196 ::std::mem::align_of::<spBoneDataArray>(),
3197 8usize,
3198 concat!("Alignment of ", stringify!(spBoneDataArray))
3199 );
3200 assert_eq!(
3201 unsafe { &(*(::std::ptr::null::<spBoneDataArray>())).size as *const _ as usize },
3202 0usize,
3203 concat!(
3204 "Offset of field: ",
3205 stringify!(spBoneDataArray),
3206 "::",
3207 stringify!(size)
3208 )
3209 );
3210 assert_eq!(
3211 unsafe { &(*(::std::ptr::null::<spBoneDataArray>())).capacity as *const _ as usize },
3212 4usize,
3213 concat!(
3214 "Offset of field: ",
3215 stringify!(spBoneDataArray),
3216 "::",
3217 stringify!(capacity)
3218 )
3219 );
3220 assert_eq!(
3221 unsafe { &(*(::std::ptr::null::<spBoneDataArray>())).items as *const _ as usize },
3222 8usize,
3223 concat!(
3224 "Offset of field: ",
3225 stringify!(spBoneDataArray),
3226 "::",
3227 stringify!(items)
3228 )
3229 );
3230}
3231extern "C" {
3232 pub fn spBoneDataArray_create(initialCapacity: ::std::os::raw::c_int) -> *mut spBoneDataArray;
3233}
3234extern "C" {
3235 pub fn spBoneDataArray_dispose(self_: *mut spBoneDataArray);
3236}
3237extern "C" {
3238 pub fn spBoneDataArray_clear(self_: *mut spBoneDataArray);
3239}
3240extern "C" {
3241 pub fn spBoneDataArray_setSize(
3242 self_: *mut spBoneDataArray,
3243 newSize: ::std::os::raw::c_int,
3244 ) -> *mut spBoneDataArray;
3245}
3246extern "C" {
3247 pub fn spBoneDataArray_ensureCapacity(
3248 self_: *mut spBoneDataArray,
3249 newCapacity: ::std::os::raw::c_int,
3250 );
3251}
3252extern "C" {
3253 pub fn spBoneDataArray_add(self_: *mut spBoneDataArray, value: *mut spBoneData);
3254}
3255extern "C" {
3256 pub fn spBoneDataArray_addAll(self_: *mut spBoneDataArray, other: *mut spBoneDataArray);
3257}
3258extern "C" {
3259 pub fn spBoneDataArray_addAllValues(
3260 self_: *mut spBoneDataArray,
3261 values: *mut *mut spBoneData,
3262 offset: ::std::os::raw::c_int,
3263 count: ::std::os::raw::c_int,
3264 );
3265}
3266extern "C" {
3267 pub fn spBoneDataArray_removeAt(self_: *mut spBoneDataArray, index: ::std::os::raw::c_int);
3268}
3269extern "C" {
3270 pub fn spBoneDataArray_contains(
3271 self_: *mut spBoneDataArray,
3272 value: *mut spBoneData,
3273 ) -> ::std::os::raw::c_int;
3274}
3275extern "C" {
3276 pub fn spBoneDataArray_pop(self_: *mut spBoneDataArray) -> *mut spBoneData;
3277}
3278extern "C" {
3279 pub fn spBoneDataArray_peek(self_: *mut spBoneDataArray) -> *mut spBoneData;
3280}
3281#[repr(C)]
3282#[derive(Debug, Copy, Clone)]
3283pub struct spIkConstraintDataArray {
3284 pub size: ::std::os::raw::c_int,
3285 pub capacity: ::std::os::raw::c_int,
3286 pub items: *mut *mut spIkConstraintData,
3287}
3288#[test]
3289fn bindgen_test_layout_spIkConstraintDataArray() {
3290 assert_eq!(
3291 ::std::mem::size_of::<spIkConstraintDataArray>(),
3292 16usize,
3293 concat!("Size of: ", stringify!(spIkConstraintDataArray))
3294 );
3295 assert_eq!(
3296 ::std::mem::align_of::<spIkConstraintDataArray>(),
3297 8usize,
3298 concat!("Alignment of ", stringify!(spIkConstraintDataArray))
3299 );
3300 assert_eq!(
3301 unsafe { &(*(::std::ptr::null::<spIkConstraintDataArray>())).size as *const _ as usize },
3302 0usize,
3303 concat!(
3304 "Offset of field: ",
3305 stringify!(spIkConstraintDataArray),
3306 "::",
3307 stringify!(size)
3308 )
3309 );
3310 assert_eq!(
3311 unsafe {
3312 &(*(::std::ptr::null::<spIkConstraintDataArray>())).capacity as *const _ as usize
3313 },
3314 4usize,
3315 concat!(
3316 "Offset of field: ",
3317 stringify!(spIkConstraintDataArray),
3318 "::",
3319 stringify!(capacity)
3320 )
3321 );
3322 assert_eq!(
3323 unsafe { &(*(::std::ptr::null::<spIkConstraintDataArray>())).items as *const _ as usize },
3324 8usize,
3325 concat!(
3326 "Offset of field: ",
3327 stringify!(spIkConstraintDataArray),
3328 "::",
3329 stringify!(items)
3330 )
3331 );
3332}
3333extern "C" {
3334 pub fn spIkConstraintDataArray_create(
3335 initialCapacity: ::std::os::raw::c_int,
3336 ) -> *mut spIkConstraintDataArray;
3337}
3338extern "C" {
3339 pub fn spIkConstraintDataArray_dispose(self_: *mut spIkConstraintDataArray);
3340}
3341extern "C" {
3342 pub fn spIkConstraintDataArray_clear(self_: *mut spIkConstraintDataArray);
3343}
3344extern "C" {
3345 pub fn spIkConstraintDataArray_setSize(
3346 self_: *mut spIkConstraintDataArray,
3347 newSize: ::std::os::raw::c_int,
3348 ) -> *mut spIkConstraintDataArray;
3349}
3350extern "C" {
3351 pub fn spIkConstraintDataArray_ensureCapacity(
3352 self_: *mut spIkConstraintDataArray,
3353 newCapacity: ::std::os::raw::c_int,
3354 );
3355}
3356extern "C" {
3357 pub fn spIkConstraintDataArray_add(
3358 self_: *mut spIkConstraintDataArray,
3359 value: *mut spIkConstraintData,
3360 );
3361}
3362extern "C" {
3363 pub fn spIkConstraintDataArray_addAll(
3364 self_: *mut spIkConstraintDataArray,
3365 other: *mut spIkConstraintDataArray,
3366 );
3367}
3368extern "C" {
3369 pub fn spIkConstraintDataArray_addAllValues(
3370 self_: *mut spIkConstraintDataArray,
3371 values: *mut *mut spIkConstraintData,
3372 offset: ::std::os::raw::c_int,
3373 count: ::std::os::raw::c_int,
3374 );
3375}
3376extern "C" {
3377 pub fn spIkConstraintDataArray_removeAt(
3378 self_: *mut spIkConstraintDataArray,
3379 index: ::std::os::raw::c_int,
3380 );
3381}
3382extern "C" {
3383 pub fn spIkConstraintDataArray_contains(
3384 self_: *mut spIkConstraintDataArray,
3385 value: *mut spIkConstraintData,
3386 ) -> ::std::os::raw::c_int;
3387}
3388extern "C" {
3389 pub fn spIkConstraintDataArray_pop(
3390 self_: *mut spIkConstraintDataArray,
3391 ) -> *mut spIkConstraintData;
3392}
3393extern "C" {
3394 pub fn spIkConstraintDataArray_peek(
3395 self_: *mut spIkConstraintDataArray,
3396 ) -> *mut spIkConstraintData;
3397}
3398#[repr(C)]
3399#[derive(Debug, Copy, Clone)]
3400pub struct spTransformConstraintDataArray {
3401 pub size: ::std::os::raw::c_int,
3402 pub capacity: ::std::os::raw::c_int,
3403 pub items: *mut *mut spTransformConstraintData,
3404}
3405#[test]
3406fn bindgen_test_layout_spTransformConstraintDataArray() {
3407 assert_eq!(
3408 ::std::mem::size_of::<spTransformConstraintDataArray>(),
3409 16usize,
3410 concat!("Size of: ", stringify!(spTransformConstraintDataArray))
3411 );
3412 assert_eq!(
3413 ::std::mem::align_of::<spTransformConstraintDataArray>(),
3414 8usize,
3415 concat!("Alignment of ", stringify!(spTransformConstraintDataArray))
3416 );
3417 assert_eq!(
3418 unsafe {
3419 &(*(::std::ptr::null::<spTransformConstraintDataArray>())).size as *const _ as usize
3420 },
3421 0usize,
3422 concat!(
3423 "Offset of field: ",
3424 stringify!(spTransformConstraintDataArray),
3425 "::",
3426 stringify!(size)
3427 )
3428 );
3429 assert_eq!(
3430 unsafe {
3431 &(*(::std::ptr::null::<spTransformConstraintDataArray>())).capacity as *const _ as usize
3432 },
3433 4usize,
3434 concat!(
3435 "Offset of field: ",
3436 stringify!(spTransformConstraintDataArray),
3437 "::",
3438 stringify!(capacity)
3439 )
3440 );
3441 assert_eq!(
3442 unsafe {
3443 &(*(::std::ptr::null::<spTransformConstraintDataArray>())).items as *const _ as usize
3444 },
3445 8usize,
3446 concat!(
3447 "Offset of field: ",
3448 stringify!(spTransformConstraintDataArray),
3449 "::",
3450 stringify!(items)
3451 )
3452 );
3453}
3454extern "C" {
3455 pub fn spTransformConstraintDataArray_create(
3456 initialCapacity: ::std::os::raw::c_int,
3457 ) -> *mut spTransformConstraintDataArray;
3458}
3459extern "C" {
3460 pub fn spTransformConstraintDataArray_dispose(self_: *mut spTransformConstraintDataArray);
3461}
3462extern "C" {
3463 pub fn spTransformConstraintDataArray_clear(self_: *mut spTransformConstraintDataArray);
3464}
3465extern "C" {
3466 pub fn spTransformConstraintDataArray_setSize(
3467 self_: *mut spTransformConstraintDataArray,
3468 newSize: ::std::os::raw::c_int,
3469 ) -> *mut spTransformConstraintDataArray;
3470}
3471extern "C" {
3472 pub fn spTransformConstraintDataArray_ensureCapacity(
3473 self_: *mut spTransformConstraintDataArray,
3474 newCapacity: ::std::os::raw::c_int,
3475 );
3476}
3477extern "C" {
3478 pub fn spTransformConstraintDataArray_add(
3479 self_: *mut spTransformConstraintDataArray,
3480 value: *mut spTransformConstraintData,
3481 );
3482}
3483extern "C" {
3484 pub fn spTransformConstraintDataArray_addAll(
3485 self_: *mut spTransformConstraintDataArray,
3486 other: *mut spTransformConstraintDataArray,
3487 );
3488}
3489extern "C" {
3490 pub fn spTransformConstraintDataArray_addAllValues(
3491 self_: *mut spTransformConstraintDataArray,
3492 values: *mut *mut spTransformConstraintData,
3493 offset: ::std::os::raw::c_int,
3494 count: ::std::os::raw::c_int,
3495 );
3496}
3497extern "C" {
3498 pub fn spTransformConstraintDataArray_removeAt(
3499 self_: *mut spTransformConstraintDataArray,
3500 index: ::std::os::raw::c_int,
3501 );
3502}
3503extern "C" {
3504 pub fn spTransformConstraintDataArray_contains(
3505 self_: *mut spTransformConstraintDataArray,
3506 value: *mut spTransformConstraintData,
3507 ) -> ::std::os::raw::c_int;
3508}
3509extern "C" {
3510 pub fn spTransformConstraintDataArray_pop(
3511 self_: *mut spTransformConstraintDataArray,
3512 ) -> *mut spTransformConstraintData;
3513}
3514extern "C" {
3515 pub fn spTransformConstraintDataArray_peek(
3516 self_: *mut spTransformConstraintDataArray,
3517 ) -> *mut spTransformConstraintData;
3518}
3519#[repr(C)]
3520#[derive(Debug, Copy, Clone)]
3521pub struct spPathConstraintDataArray {
3522 pub size: ::std::os::raw::c_int,
3523 pub capacity: ::std::os::raw::c_int,
3524 pub items: *mut *mut spPathConstraintData,
3525}
3526#[test]
3527fn bindgen_test_layout_spPathConstraintDataArray() {
3528 assert_eq!(
3529 ::std::mem::size_of::<spPathConstraintDataArray>(),
3530 16usize,
3531 concat!("Size of: ", stringify!(spPathConstraintDataArray))
3532 );
3533 assert_eq!(
3534 ::std::mem::align_of::<spPathConstraintDataArray>(),
3535 8usize,
3536 concat!("Alignment of ", stringify!(spPathConstraintDataArray))
3537 );
3538 assert_eq!(
3539 unsafe { &(*(::std::ptr::null::<spPathConstraintDataArray>())).size as *const _ as usize },
3540 0usize,
3541 concat!(
3542 "Offset of field: ",
3543 stringify!(spPathConstraintDataArray),
3544 "::",
3545 stringify!(size)
3546 )
3547 );
3548 assert_eq!(
3549 unsafe {
3550 &(*(::std::ptr::null::<spPathConstraintDataArray>())).capacity as *const _ as usize
3551 },
3552 4usize,
3553 concat!(
3554 "Offset of field: ",
3555 stringify!(spPathConstraintDataArray),
3556 "::",
3557 stringify!(capacity)
3558 )
3559 );
3560 assert_eq!(
3561 unsafe { &(*(::std::ptr::null::<spPathConstraintDataArray>())).items as *const _ as usize },
3562 8usize,
3563 concat!(
3564 "Offset of field: ",
3565 stringify!(spPathConstraintDataArray),
3566 "::",
3567 stringify!(items)
3568 )
3569 );
3570}
3571extern "C" {
3572 pub fn spPathConstraintDataArray_create(
3573 initialCapacity: ::std::os::raw::c_int,
3574 ) -> *mut spPathConstraintDataArray;
3575}
3576extern "C" {
3577 pub fn spPathConstraintDataArray_dispose(self_: *mut spPathConstraintDataArray);
3578}
3579extern "C" {
3580 pub fn spPathConstraintDataArray_clear(self_: *mut spPathConstraintDataArray);
3581}
3582extern "C" {
3583 pub fn spPathConstraintDataArray_setSize(
3584 self_: *mut spPathConstraintDataArray,
3585 newSize: ::std::os::raw::c_int,
3586 ) -> *mut spPathConstraintDataArray;
3587}
3588extern "C" {
3589 pub fn spPathConstraintDataArray_ensureCapacity(
3590 self_: *mut spPathConstraintDataArray,
3591 newCapacity: ::std::os::raw::c_int,
3592 );
3593}
3594extern "C" {
3595 pub fn spPathConstraintDataArray_add(
3596 self_: *mut spPathConstraintDataArray,
3597 value: *mut spPathConstraintData,
3598 );
3599}
3600extern "C" {
3601 pub fn spPathConstraintDataArray_addAll(
3602 self_: *mut spPathConstraintDataArray,
3603 other: *mut spPathConstraintDataArray,
3604 );
3605}
3606extern "C" {
3607 pub fn spPathConstraintDataArray_addAllValues(
3608 self_: *mut spPathConstraintDataArray,
3609 values: *mut *mut spPathConstraintData,
3610 offset: ::std::os::raw::c_int,
3611 count: ::std::os::raw::c_int,
3612 );
3613}
3614extern "C" {
3615 pub fn spPathConstraintDataArray_removeAt(
3616 self_: *mut spPathConstraintDataArray,
3617 index: ::std::os::raw::c_int,
3618 );
3619}
3620extern "C" {
3621 pub fn spPathConstraintDataArray_contains(
3622 self_: *mut spPathConstraintDataArray,
3623 value: *mut spPathConstraintData,
3624 ) -> ::std::os::raw::c_int;
3625}
3626extern "C" {
3627 pub fn spPathConstraintDataArray_pop(
3628 self_: *mut spPathConstraintDataArray,
3629 ) -> *mut spPathConstraintData;
3630}
3631extern "C" {
3632 pub fn spPathConstraintDataArray_peek(
3633 self_: *mut spPathConstraintDataArray,
3634 ) -> *mut spPathConstraintData;
3635}
3636#[repr(C)]
3637#[derive(Debug, Copy, Clone)]
3638pub struct spSkin {
3639 pub name: *const ::std::os::raw::c_char,
3640 pub bones: *mut spBoneDataArray,
3641 pub ikConstraints: *mut spIkConstraintDataArray,
3642 pub transformConstraints: *mut spTransformConstraintDataArray,
3643 pub pathConstraints: *mut spPathConstraintDataArray,
3644}
3645#[test]
3646fn bindgen_test_layout_spSkin() {
3647 assert_eq!(
3648 ::std::mem::size_of::<spSkin>(),
3649 40usize,
3650 concat!("Size of: ", stringify!(spSkin))
3651 );
3652 assert_eq!(
3653 ::std::mem::align_of::<spSkin>(),
3654 8usize,
3655 concat!("Alignment of ", stringify!(spSkin))
3656 );
3657 assert_eq!(
3658 unsafe { &(*(::std::ptr::null::<spSkin>())).name as *const _ as usize },
3659 0usize,
3660 concat!(
3661 "Offset of field: ",
3662 stringify!(spSkin),
3663 "::",
3664 stringify!(name)
3665 )
3666 );
3667 assert_eq!(
3668 unsafe { &(*(::std::ptr::null::<spSkin>())).bones as *const _ as usize },
3669 8usize,
3670 concat!(
3671 "Offset of field: ",
3672 stringify!(spSkin),
3673 "::",
3674 stringify!(bones)
3675 )
3676 );
3677 assert_eq!(
3678 unsafe { &(*(::std::ptr::null::<spSkin>())).ikConstraints as *const _ as usize },
3679 16usize,
3680 concat!(
3681 "Offset of field: ",
3682 stringify!(spSkin),
3683 "::",
3684 stringify!(ikConstraints)
3685 )
3686 );
3687 assert_eq!(
3688 unsafe { &(*(::std::ptr::null::<spSkin>())).transformConstraints as *const _ as usize },
3689 24usize,
3690 concat!(
3691 "Offset of field: ",
3692 stringify!(spSkin),
3693 "::",
3694 stringify!(transformConstraints)
3695 )
3696 );
3697 assert_eq!(
3698 unsafe { &(*(::std::ptr::null::<spSkin>())).pathConstraints as *const _ as usize },
3699 32usize,
3700 concat!(
3701 "Offset of field: ",
3702 stringify!(spSkin),
3703 "::",
3704 stringify!(pathConstraints)
3705 )
3706 );
3707}
3708pub type spSkinEntry = _Entry;
3709#[repr(C)]
3710#[derive(Debug, Copy, Clone)]
3711pub struct _Entry {
3712 pub slotIndex: ::std::os::raw::c_int,
3713 pub name: *const ::std::os::raw::c_char,
3714 pub attachment: *mut spAttachment,
3715 pub next: *mut _Entry,
3716}
3717#[test]
3718fn bindgen_test_layout__Entry() {
3719 assert_eq!(
3720 ::std::mem::size_of::<_Entry>(),
3721 32usize,
3722 concat!("Size of: ", stringify!(_Entry))
3723 );
3724 assert_eq!(
3725 ::std::mem::align_of::<_Entry>(),
3726 8usize,
3727 concat!("Alignment of ", stringify!(_Entry))
3728 );
3729 assert_eq!(
3730 unsafe { &(*(::std::ptr::null::<_Entry>())).slotIndex as *const _ as usize },
3731 0usize,
3732 concat!(
3733 "Offset of field: ",
3734 stringify!(_Entry),
3735 "::",
3736 stringify!(slotIndex)
3737 )
3738 );
3739 assert_eq!(
3740 unsafe { &(*(::std::ptr::null::<_Entry>())).name as *const _ as usize },
3741 8usize,
3742 concat!(
3743 "Offset of field: ",
3744 stringify!(_Entry),
3745 "::",
3746 stringify!(name)
3747 )
3748 );
3749 assert_eq!(
3750 unsafe { &(*(::std::ptr::null::<_Entry>())).attachment as *const _ as usize },
3751 16usize,
3752 concat!(
3753 "Offset of field: ",
3754 stringify!(_Entry),
3755 "::",
3756 stringify!(attachment)
3757 )
3758 );
3759 assert_eq!(
3760 unsafe { &(*(::std::ptr::null::<_Entry>())).next as *const _ as usize },
3761 24usize,
3762 concat!(
3763 "Offset of field: ",
3764 stringify!(_Entry),
3765 "::",
3766 stringify!(next)
3767 )
3768 );
3769}
3770#[repr(C)]
3771#[derive(Debug, Copy, Clone)]
3772pub struct _SkinHashTableEntry {
3773 pub entry: *mut _Entry,
3774 pub next: *mut _SkinHashTableEntry,
3775}
3776#[test]
3777fn bindgen_test_layout__SkinHashTableEntry() {
3778 assert_eq!(
3779 ::std::mem::size_of::<_SkinHashTableEntry>(),
3780 16usize,
3781 concat!("Size of: ", stringify!(_SkinHashTableEntry))
3782 );
3783 assert_eq!(
3784 ::std::mem::align_of::<_SkinHashTableEntry>(),
3785 8usize,
3786 concat!("Alignment of ", stringify!(_SkinHashTableEntry))
3787 );
3788 assert_eq!(
3789 unsafe { &(*(::std::ptr::null::<_SkinHashTableEntry>())).entry as *const _ as usize },
3790 0usize,
3791 concat!(
3792 "Offset of field: ",
3793 stringify!(_SkinHashTableEntry),
3794 "::",
3795 stringify!(entry)
3796 )
3797 );
3798 assert_eq!(
3799 unsafe { &(*(::std::ptr::null::<_SkinHashTableEntry>())).next as *const _ as usize },
3800 8usize,
3801 concat!(
3802 "Offset of field: ",
3803 stringify!(_SkinHashTableEntry),
3804 "::",
3805 stringify!(next)
3806 )
3807 );
3808}
3809#[repr(C)]
3810#[derive(Copy, Clone)]
3811pub struct _spSkin {
3812 pub super_: spSkin,
3813 pub entries: *mut _Entry,
3814 pub entriesHashTable: [*mut _SkinHashTableEntry; 100usize],
3815}
3816#[test]
3817fn bindgen_test_layout__spSkin() {
3818 assert_eq!(
3819 ::std::mem::size_of::<_spSkin>(),
3820 848usize,
3821 concat!("Size of: ", stringify!(_spSkin))
3822 );
3823 assert_eq!(
3824 ::std::mem::align_of::<_spSkin>(),
3825 8usize,
3826 concat!("Alignment of ", stringify!(_spSkin))
3827 );
3828 assert_eq!(
3829 unsafe { &(*(::std::ptr::null::<_spSkin>())).super_ as *const _ as usize },
3830 0usize,
3831 concat!(
3832 "Offset of field: ",
3833 stringify!(_spSkin),
3834 "::",
3835 stringify!(super_)
3836 )
3837 );
3838 assert_eq!(
3839 unsafe { &(*(::std::ptr::null::<_spSkin>())).entries as *const _ as usize },
3840 40usize,
3841 concat!(
3842 "Offset of field: ",
3843 stringify!(_spSkin),
3844 "::",
3845 stringify!(entries)
3846 )
3847 );
3848 assert_eq!(
3849 unsafe { &(*(::std::ptr::null::<_spSkin>())).entriesHashTable as *const _ as usize },
3850 48usize,
3851 concat!(
3852 "Offset of field: ",
3853 stringify!(_spSkin),
3854 "::",
3855 stringify!(entriesHashTable)
3856 )
3857 );
3858}
3859extern "C" {
3860 pub fn spSkin_create(name: *const ::std::os::raw::c_char) -> *mut spSkin;
3861}
3862extern "C" {
3863 pub fn spSkin_dispose(self_: *mut spSkin);
3864}
3865extern "C" {
3866 pub fn spSkin_setAttachment(
3867 self_: *mut spSkin,
3868 slotIndex: ::std::os::raw::c_int,
3869 name: *const ::std::os::raw::c_char,
3870 attachment: *mut spAttachment,
3871 );
3872}
3873extern "C" {
3874 pub fn spSkin_getAttachment(
3875 self_: *const spSkin,
3876 slotIndex: ::std::os::raw::c_int,
3877 name: *const ::std::os::raw::c_char,
3878 ) -> *mut spAttachment;
3879}
3880extern "C" {
3881 pub fn spSkin_getAttachmentName(
3882 self_: *const spSkin,
3883 slotIndex: ::std::os::raw::c_int,
3884 attachmentIndex: ::std::os::raw::c_int,
3885 ) -> *const ::std::os::raw::c_char;
3886}
3887extern "C" {
3888 #[doc = " Attach each attachment in this skin if the corresponding attachment in oldSkin is currently attached."]
3889 pub fn spSkin_attachAll(
3890 self_: *const spSkin,
3891 skeleton: *mut spSkeleton,
3892 oldspSkin: *const spSkin,
3893 );
3894}
3895extern "C" {
3896 #[doc = " Adds all attachments, bones, and constraints from the specified skin to this skin."]
3897 pub fn spSkin_addSkin(self_: *mut spSkin, other: *const spSkin);
3898}
3899extern "C" {
3900 #[doc = " Adds all attachments, bones, and constraints from the specified skin to this skin. Attachments are deep copied."]
3901 pub fn spSkin_copySkin(self_: *mut spSkin, other: *const spSkin);
3902}
3903extern "C" {
3904 #[doc = " Returns all attachments in this skin."]
3905 pub fn spSkin_getAttachments(self_: *const spSkin) -> *mut spSkinEntry;
3906}
3907extern "C" {
3908 #[doc = " Clears all attachments, bones, and constraints."]
3909 pub fn spSkin_clear(self_: *mut spSkin);
3910}
3911#[repr(C)]
3912#[derive(Debug, Copy, Clone)]
3913pub struct spSkeletonData {
3914 pub version: *const ::std::os::raw::c_char,
3915 pub hash: *const ::std::os::raw::c_char,
3916 pub x: f32,
3917 pub y: f32,
3918 pub width: f32,
3919 pub height: f32,
3920 pub stringsCount: ::std::os::raw::c_int,
3921 pub strings: *mut *mut ::std::os::raw::c_char,
3922 pub bonesCount: ::std::os::raw::c_int,
3923 pub bones: *mut *mut spBoneData,
3924 pub slotsCount: ::std::os::raw::c_int,
3925 pub slots: *mut *mut spSlotData,
3926 pub skinsCount: ::std::os::raw::c_int,
3927 pub skins: *mut *mut spSkin,
3928 pub defaultSkin: *mut spSkin,
3929 pub eventsCount: ::std::os::raw::c_int,
3930 pub events: *mut *mut spEventData,
3931 pub animationsCount: ::std::os::raw::c_int,
3932 pub animations: *mut *mut spAnimation,
3933 pub ikConstraintsCount: ::std::os::raw::c_int,
3934 pub ikConstraints: *mut *mut spIkConstraintData,
3935 pub transformConstraintsCount: ::std::os::raw::c_int,
3936 pub transformConstraints: *mut *mut spTransformConstraintData,
3937 pub pathConstraintsCount: ::std::os::raw::c_int,
3938 pub pathConstraints: *mut *mut spPathConstraintData,
3939}
3940#[test]
3941fn bindgen_test_layout_spSkeletonData() {
3942 assert_eq!(
3943 ::std::mem::size_of::<spSkeletonData>(),
3944 184usize,
3945 concat!("Size of: ", stringify!(spSkeletonData))
3946 );
3947 assert_eq!(
3948 ::std::mem::align_of::<spSkeletonData>(),
3949 8usize,
3950 concat!("Alignment of ", stringify!(spSkeletonData))
3951 );
3952 assert_eq!(
3953 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).version as *const _ as usize },
3954 0usize,
3955 concat!(
3956 "Offset of field: ",
3957 stringify!(spSkeletonData),
3958 "::",
3959 stringify!(version)
3960 )
3961 );
3962 assert_eq!(
3963 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).hash as *const _ as usize },
3964 8usize,
3965 concat!(
3966 "Offset of field: ",
3967 stringify!(spSkeletonData),
3968 "::",
3969 stringify!(hash)
3970 )
3971 );
3972 assert_eq!(
3973 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).x as *const _ as usize },
3974 16usize,
3975 concat!(
3976 "Offset of field: ",
3977 stringify!(spSkeletonData),
3978 "::",
3979 stringify!(x)
3980 )
3981 );
3982 assert_eq!(
3983 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).y as *const _ as usize },
3984 20usize,
3985 concat!(
3986 "Offset of field: ",
3987 stringify!(spSkeletonData),
3988 "::",
3989 stringify!(y)
3990 )
3991 );
3992 assert_eq!(
3993 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).width as *const _ as usize },
3994 24usize,
3995 concat!(
3996 "Offset of field: ",
3997 stringify!(spSkeletonData),
3998 "::",
3999 stringify!(width)
4000 )
4001 );
4002 assert_eq!(
4003 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).height as *const _ as usize },
4004 28usize,
4005 concat!(
4006 "Offset of field: ",
4007 stringify!(spSkeletonData),
4008 "::",
4009 stringify!(height)
4010 )
4011 );
4012 assert_eq!(
4013 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).stringsCount as *const _ as usize },
4014 32usize,
4015 concat!(
4016 "Offset of field: ",
4017 stringify!(spSkeletonData),
4018 "::",
4019 stringify!(stringsCount)
4020 )
4021 );
4022 assert_eq!(
4023 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).strings as *const _ as usize },
4024 40usize,
4025 concat!(
4026 "Offset of field: ",
4027 stringify!(spSkeletonData),
4028 "::",
4029 stringify!(strings)
4030 )
4031 );
4032 assert_eq!(
4033 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).bonesCount as *const _ as usize },
4034 48usize,
4035 concat!(
4036 "Offset of field: ",
4037 stringify!(spSkeletonData),
4038 "::",
4039 stringify!(bonesCount)
4040 )
4041 );
4042 assert_eq!(
4043 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).bones as *const _ as usize },
4044 56usize,
4045 concat!(
4046 "Offset of field: ",
4047 stringify!(spSkeletonData),
4048 "::",
4049 stringify!(bones)
4050 )
4051 );
4052 assert_eq!(
4053 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).slotsCount as *const _ as usize },
4054 64usize,
4055 concat!(
4056 "Offset of field: ",
4057 stringify!(spSkeletonData),
4058 "::",
4059 stringify!(slotsCount)
4060 )
4061 );
4062 assert_eq!(
4063 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).slots as *const _ as usize },
4064 72usize,
4065 concat!(
4066 "Offset of field: ",
4067 stringify!(spSkeletonData),
4068 "::",
4069 stringify!(slots)
4070 )
4071 );
4072 assert_eq!(
4073 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).skinsCount as *const _ as usize },
4074 80usize,
4075 concat!(
4076 "Offset of field: ",
4077 stringify!(spSkeletonData),
4078 "::",
4079 stringify!(skinsCount)
4080 )
4081 );
4082 assert_eq!(
4083 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).skins as *const _ as usize },
4084 88usize,
4085 concat!(
4086 "Offset of field: ",
4087 stringify!(spSkeletonData),
4088 "::",
4089 stringify!(skins)
4090 )
4091 );
4092 assert_eq!(
4093 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).defaultSkin as *const _ as usize },
4094 96usize,
4095 concat!(
4096 "Offset of field: ",
4097 stringify!(spSkeletonData),
4098 "::",
4099 stringify!(defaultSkin)
4100 )
4101 );
4102 assert_eq!(
4103 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).eventsCount as *const _ as usize },
4104 104usize,
4105 concat!(
4106 "Offset of field: ",
4107 stringify!(spSkeletonData),
4108 "::",
4109 stringify!(eventsCount)
4110 )
4111 );
4112 assert_eq!(
4113 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).events as *const _ as usize },
4114 112usize,
4115 concat!(
4116 "Offset of field: ",
4117 stringify!(spSkeletonData),
4118 "::",
4119 stringify!(events)
4120 )
4121 );
4122 assert_eq!(
4123 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).animationsCount as *const _ as usize },
4124 120usize,
4125 concat!(
4126 "Offset of field: ",
4127 stringify!(spSkeletonData),
4128 "::",
4129 stringify!(animationsCount)
4130 )
4131 );
4132 assert_eq!(
4133 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).animations as *const _ as usize },
4134 128usize,
4135 concat!(
4136 "Offset of field: ",
4137 stringify!(spSkeletonData),
4138 "::",
4139 stringify!(animations)
4140 )
4141 );
4142 assert_eq!(
4143 unsafe {
4144 &(*(::std::ptr::null::<spSkeletonData>())).ikConstraintsCount as *const _ as usize
4145 },
4146 136usize,
4147 concat!(
4148 "Offset of field: ",
4149 stringify!(spSkeletonData),
4150 "::",
4151 stringify!(ikConstraintsCount)
4152 )
4153 );
4154 assert_eq!(
4155 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).ikConstraints as *const _ as usize },
4156 144usize,
4157 concat!(
4158 "Offset of field: ",
4159 stringify!(spSkeletonData),
4160 "::",
4161 stringify!(ikConstraints)
4162 )
4163 );
4164 assert_eq!(
4165 unsafe {
4166 &(*(::std::ptr::null::<spSkeletonData>())).transformConstraintsCount as *const _
4167 as usize
4168 },
4169 152usize,
4170 concat!(
4171 "Offset of field: ",
4172 stringify!(spSkeletonData),
4173 "::",
4174 stringify!(transformConstraintsCount)
4175 )
4176 );
4177 assert_eq!(
4178 unsafe {
4179 &(*(::std::ptr::null::<spSkeletonData>())).transformConstraints as *const _ as usize
4180 },
4181 160usize,
4182 concat!(
4183 "Offset of field: ",
4184 stringify!(spSkeletonData),
4185 "::",
4186 stringify!(transformConstraints)
4187 )
4188 );
4189 assert_eq!(
4190 unsafe {
4191 &(*(::std::ptr::null::<spSkeletonData>())).pathConstraintsCount as *const _ as usize
4192 },
4193 168usize,
4194 concat!(
4195 "Offset of field: ",
4196 stringify!(spSkeletonData),
4197 "::",
4198 stringify!(pathConstraintsCount)
4199 )
4200 );
4201 assert_eq!(
4202 unsafe { &(*(::std::ptr::null::<spSkeletonData>())).pathConstraints as *const _ as usize },
4203 176usize,
4204 concat!(
4205 "Offset of field: ",
4206 stringify!(spSkeletonData),
4207 "::",
4208 stringify!(pathConstraints)
4209 )
4210 );
4211}
4212extern "C" {
4213 pub fn spSkeletonData_create() -> *mut spSkeletonData;
4214}
4215extern "C" {
4216 pub fn spSkeletonData_dispose(self_: *mut spSkeletonData);
4217}
4218extern "C" {
4219 pub fn spSkeletonData_findBone(
4220 self_: *const spSkeletonData,
4221 boneName: *const ::std::os::raw::c_char,
4222 ) -> *mut spBoneData;
4223}
4224extern "C" {
4225 pub fn spSkeletonData_findBoneIndex(
4226 self_: *const spSkeletonData,
4227 boneName: *const ::std::os::raw::c_char,
4228 ) -> ::std::os::raw::c_int;
4229}
4230extern "C" {
4231 pub fn spSkeletonData_findSlot(
4232 self_: *const spSkeletonData,
4233 slotName: *const ::std::os::raw::c_char,
4234 ) -> *mut spSlotData;
4235}
4236extern "C" {
4237 pub fn spSkeletonData_findSlotIndex(
4238 self_: *const spSkeletonData,
4239 slotName: *const ::std::os::raw::c_char,
4240 ) -> ::std::os::raw::c_int;
4241}
4242extern "C" {
4243 pub fn spSkeletonData_findSkin(
4244 self_: *const spSkeletonData,
4245 skinName: *const ::std::os::raw::c_char,
4246 ) -> *mut spSkin;
4247}
4248extern "C" {
4249 pub fn spSkeletonData_findEvent(
4250 self_: *const spSkeletonData,
4251 eventName: *const ::std::os::raw::c_char,
4252 ) -> *mut spEventData;
4253}
4254extern "C" {
4255 pub fn spSkeletonData_findAnimation(
4256 self_: *const spSkeletonData,
4257 animationName: *const ::std::os::raw::c_char,
4258 ) -> *mut spAnimation;
4259}
4260extern "C" {
4261 pub fn spSkeletonData_findIkConstraint(
4262 self_: *const spSkeletonData,
4263 constraintName: *const ::std::os::raw::c_char,
4264 ) -> *mut spIkConstraintData;
4265}
4266extern "C" {
4267 pub fn spSkeletonData_findTransformConstraint(
4268 self_: *const spSkeletonData,
4269 constraintName: *const ::std::os::raw::c_char,
4270 ) -> *mut spTransformConstraintData;
4271}
4272extern "C" {
4273 pub fn spSkeletonData_findPathConstraint(
4274 self_: *const spSkeletonData,
4275 constraintName: *const ::std::os::raw::c_char,
4276 ) -> *mut spPathConstraintData;
4277}
4278#[repr(C)]
4279#[derive(Debug, Copy, Clone)]
4280pub struct spAnimationStateData {
4281 pub skeletonData: *mut spSkeletonData,
4282 pub defaultMix: f32,
4283 pub entries: *const ::std::os::raw::c_void,
4284}
4285#[test]
4286fn bindgen_test_layout_spAnimationStateData() {
4287 assert_eq!(
4288 ::std::mem::size_of::<spAnimationStateData>(),
4289 24usize,
4290 concat!("Size of: ", stringify!(spAnimationStateData))
4291 );
4292 assert_eq!(
4293 ::std::mem::align_of::<spAnimationStateData>(),
4294 8usize,
4295 concat!("Alignment of ", stringify!(spAnimationStateData))
4296 );
4297 assert_eq!(
4298 unsafe {
4299 &(*(::std::ptr::null::<spAnimationStateData>())).skeletonData as *const _ as usize
4300 },
4301 0usize,
4302 concat!(
4303 "Offset of field: ",
4304 stringify!(spAnimationStateData),
4305 "::",
4306 stringify!(skeletonData)
4307 )
4308 );
4309 assert_eq!(
4310 unsafe { &(*(::std::ptr::null::<spAnimationStateData>())).defaultMix as *const _ as usize },
4311 8usize,
4312 concat!(
4313 "Offset of field: ",
4314 stringify!(spAnimationStateData),
4315 "::",
4316 stringify!(defaultMix)
4317 )
4318 );
4319 assert_eq!(
4320 unsafe { &(*(::std::ptr::null::<spAnimationStateData>())).entries as *const _ as usize },
4321 16usize,
4322 concat!(
4323 "Offset of field: ",
4324 stringify!(spAnimationStateData),
4325 "::",
4326 stringify!(entries)
4327 )
4328 );
4329}
4330extern "C" {
4331 pub fn spAnimationStateData_create(
4332 skeletonData: *mut spSkeletonData,
4333 ) -> *mut spAnimationStateData;
4334}
4335extern "C" {
4336 pub fn spAnimationStateData_dispose(self_: *mut spAnimationStateData);
4337}
4338extern "C" {
4339 pub fn spAnimationStateData_setMixByName(
4340 self_: *mut spAnimationStateData,
4341 fromName: *const ::std::os::raw::c_char,
4342 toName: *const ::std::os::raw::c_char,
4343 duration: f32,
4344 );
4345}
4346extern "C" {
4347 pub fn spAnimationStateData_setMix(
4348 self_: *mut spAnimationStateData,
4349 from: *mut spAnimation,
4350 to: *mut spAnimation,
4351 duration: f32,
4352 );
4353}
4354extern "C" {
4355 pub fn spAnimationStateData_getMix(
4356 self_: *mut spAnimationStateData,
4357 from: *mut spAnimation,
4358 to: *mut spAnimation,
4359 ) -> f32;
4360}
4361pub const spEventType_SP_ANIMATION_START: spEventType = 0;
4362pub const spEventType_SP_ANIMATION_INTERRUPT: spEventType = 1;
4363pub const spEventType_SP_ANIMATION_END: spEventType = 2;
4364pub const spEventType_SP_ANIMATION_COMPLETE: spEventType = 3;
4365pub const spEventType_SP_ANIMATION_DISPOSE: spEventType = 4;
4366pub const spEventType_SP_ANIMATION_EVENT: spEventType = 5;
4367pub type spEventType = u32;
4368pub type spAnimationStateListener = ::std::option::Option<
4369 unsafe extern "C" fn(
4370 state: *mut spAnimationState,
4371 type_: spEventType,
4372 entry: *mut spTrackEntry,
4373 event: *mut spEvent,
4374 ),
4375>;
4376#[repr(C)]
4377#[derive(Debug, Copy, Clone)]
4378pub struct spTrackEntryArray {
4379 pub size: ::std::os::raw::c_int,
4380 pub capacity: ::std::os::raw::c_int,
4381 pub items: *mut *mut spTrackEntry,
4382}
4383#[test]
4384fn bindgen_test_layout_spTrackEntryArray() {
4385 assert_eq!(
4386 ::std::mem::size_of::<spTrackEntryArray>(),
4387 16usize,
4388 concat!("Size of: ", stringify!(spTrackEntryArray))
4389 );
4390 assert_eq!(
4391 ::std::mem::align_of::<spTrackEntryArray>(),
4392 8usize,
4393 concat!("Alignment of ", stringify!(spTrackEntryArray))
4394 );
4395 assert_eq!(
4396 unsafe { &(*(::std::ptr::null::<spTrackEntryArray>())).size as *const _ as usize },
4397 0usize,
4398 concat!(
4399 "Offset of field: ",
4400 stringify!(spTrackEntryArray),
4401 "::",
4402 stringify!(size)
4403 )
4404 );
4405 assert_eq!(
4406 unsafe { &(*(::std::ptr::null::<spTrackEntryArray>())).capacity as *const _ as usize },
4407 4usize,
4408 concat!(
4409 "Offset of field: ",
4410 stringify!(spTrackEntryArray),
4411 "::",
4412 stringify!(capacity)
4413 )
4414 );
4415 assert_eq!(
4416 unsafe { &(*(::std::ptr::null::<spTrackEntryArray>())).items as *const _ as usize },
4417 8usize,
4418 concat!(
4419 "Offset of field: ",
4420 stringify!(spTrackEntryArray),
4421 "::",
4422 stringify!(items)
4423 )
4424 );
4425}
4426extern "C" {
4427 pub fn spTrackEntryArray_create(
4428 initialCapacity: ::std::os::raw::c_int,
4429 ) -> *mut spTrackEntryArray;
4430}
4431extern "C" {
4432 pub fn spTrackEntryArray_dispose(self_: *mut spTrackEntryArray);
4433}
4434extern "C" {
4435 pub fn spTrackEntryArray_clear(self_: *mut spTrackEntryArray);
4436}
4437extern "C" {
4438 pub fn spTrackEntryArray_setSize(
4439 self_: *mut spTrackEntryArray,
4440 newSize: ::std::os::raw::c_int,
4441 ) -> *mut spTrackEntryArray;
4442}
4443extern "C" {
4444 pub fn spTrackEntryArray_ensureCapacity(
4445 self_: *mut spTrackEntryArray,
4446 newCapacity: ::std::os::raw::c_int,
4447 );
4448}
4449extern "C" {
4450 pub fn spTrackEntryArray_add(self_: *mut spTrackEntryArray, value: *mut spTrackEntry);
4451}
4452extern "C" {
4453 pub fn spTrackEntryArray_addAll(self_: *mut spTrackEntryArray, other: *mut spTrackEntryArray);
4454}
4455extern "C" {
4456 pub fn spTrackEntryArray_addAllValues(
4457 self_: *mut spTrackEntryArray,
4458 values: *mut *mut spTrackEntry,
4459 offset: ::std::os::raw::c_int,
4460 count: ::std::os::raw::c_int,
4461 );
4462}
4463extern "C" {
4464 pub fn spTrackEntryArray_removeAt(self_: *mut spTrackEntryArray, index: ::std::os::raw::c_int);
4465}
4466extern "C" {
4467 pub fn spTrackEntryArray_contains(
4468 self_: *mut spTrackEntryArray,
4469 value: *mut spTrackEntry,
4470 ) -> ::std::os::raw::c_int;
4471}
4472extern "C" {
4473 pub fn spTrackEntryArray_pop(self_: *mut spTrackEntryArray) -> *mut spTrackEntry;
4474}
4475extern "C" {
4476 pub fn spTrackEntryArray_peek(self_: *mut spTrackEntryArray) -> *mut spTrackEntry;
4477}
4478#[repr(C)]
4479#[derive(Debug, Copy, Clone)]
4480pub struct spTrackEntry {
4481 pub animation: *mut spAnimation,
4482 pub next: *mut spTrackEntry,
4483 pub mixingFrom: *mut spTrackEntry,
4484 pub mixingTo: *mut spTrackEntry,
4485 pub listener: spAnimationStateListener,
4486 pub trackIndex: ::std::os::raw::c_int,
4487 pub loop_: ::std::os::raw::c_int,
4488 pub holdPrevious: ::std::os::raw::c_int,
4489 pub eventThreshold: f32,
4490 pub attachmentThreshold: f32,
4491 pub drawOrderThreshold: f32,
4492 pub animationStart: f32,
4493 pub animationEnd: f32,
4494 pub animationLast: f32,
4495 pub nextAnimationLast: f32,
4496 pub delay: f32,
4497 pub trackTime: f32,
4498 pub trackLast: f32,
4499 pub nextTrackLast: f32,
4500 pub trackEnd: f32,
4501 pub timeScale: f32,
4502 pub alpha: f32,
4503 pub mixTime: f32,
4504 pub mixDuration: f32,
4505 pub interruptAlpha: f32,
4506 pub totalAlpha: f32,
4507 pub mixBlend: spMixBlend,
4508 pub timelineMode: *mut spIntArray,
4509 pub timelineHoldMix: *mut spTrackEntryArray,
4510 pub timelinesRotation: *mut f32,
4511 pub timelinesRotationCount: ::std::os::raw::c_int,
4512 pub rendererObject: *mut ::std::os::raw::c_void,
4513 pub userData: *mut ::std::os::raw::c_void,
4514}
4515#[test]
4516fn bindgen_test_layout_spTrackEntry() {
4517 assert_eq!(
4518 ::std::mem::size_of::<spTrackEntry>(),
4519 176usize,
4520 concat!("Size of: ", stringify!(spTrackEntry))
4521 );
4522 assert_eq!(
4523 ::std::mem::align_of::<spTrackEntry>(),
4524 8usize,
4525 concat!("Alignment of ", stringify!(spTrackEntry))
4526 );
4527 assert_eq!(
4528 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).animation as *const _ as usize },
4529 0usize,
4530 concat!(
4531 "Offset of field: ",
4532 stringify!(spTrackEntry),
4533 "::",
4534 stringify!(animation)
4535 )
4536 );
4537 assert_eq!(
4538 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).next as *const _ as usize },
4539 8usize,
4540 concat!(
4541 "Offset of field: ",
4542 stringify!(spTrackEntry),
4543 "::",
4544 stringify!(next)
4545 )
4546 );
4547 assert_eq!(
4548 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).mixingFrom as *const _ as usize },
4549 16usize,
4550 concat!(
4551 "Offset of field: ",
4552 stringify!(spTrackEntry),
4553 "::",
4554 stringify!(mixingFrom)
4555 )
4556 );
4557 assert_eq!(
4558 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).mixingTo as *const _ as usize },
4559 24usize,
4560 concat!(
4561 "Offset of field: ",
4562 stringify!(spTrackEntry),
4563 "::",
4564 stringify!(mixingTo)
4565 )
4566 );
4567 assert_eq!(
4568 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).listener as *const _ as usize },
4569 32usize,
4570 concat!(
4571 "Offset of field: ",
4572 stringify!(spTrackEntry),
4573 "::",
4574 stringify!(listener)
4575 )
4576 );
4577 assert_eq!(
4578 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).trackIndex as *const _ as usize },
4579 40usize,
4580 concat!(
4581 "Offset of field: ",
4582 stringify!(spTrackEntry),
4583 "::",
4584 stringify!(trackIndex)
4585 )
4586 );
4587 assert_eq!(
4588 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).loop_ as *const _ as usize },
4589 44usize,
4590 concat!(
4591 "Offset of field: ",
4592 stringify!(spTrackEntry),
4593 "::",
4594 stringify!(loop_)
4595 )
4596 );
4597 assert_eq!(
4598 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).holdPrevious as *const _ as usize },
4599 48usize,
4600 concat!(
4601 "Offset of field: ",
4602 stringify!(spTrackEntry),
4603 "::",
4604 stringify!(holdPrevious)
4605 )
4606 );
4607 assert_eq!(
4608 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).eventThreshold as *const _ as usize },
4609 52usize,
4610 concat!(
4611 "Offset of field: ",
4612 stringify!(spTrackEntry),
4613 "::",
4614 stringify!(eventThreshold)
4615 )
4616 );
4617 assert_eq!(
4618 unsafe {
4619 &(*(::std::ptr::null::<spTrackEntry>())).attachmentThreshold as *const _ as usize
4620 },
4621 56usize,
4622 concat!(
4623 "Offset of field: ",
4624 stringify!(spTrackEntry),
4625 "::",
4626 stringify!(attachmentThreshold)
4627 )
4628 );
4629 assert_eq!(
4630 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).drawOrderThreshold as *const _ as usize },
4631 60usize,
4632 concat!(
4633 "Offset of field: ",
4634 stringify!(spTrackEntry),
4635 "::",
4636 stringify!(drawOrderThreshold)
4637 )
4638 );
4639 assert_eq!(
4640 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).animationStart as *const _ as usize },
4641 64usize,
4642 concat!(
4643 "Offset of field: ",
4644 stringify!(spTrackEntry),
4645 "::",
4646 stringify!(animationStart)
4647 )
4648 );
4649 assert_eq!(
4650 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).animationEnd as *const _ as usize },
4651 68usize,
4652 concat!(
4653 "Offset of field: ",
4654 stringify!(spTrackEntry),
4655 "::",
4656 stringify!(animationEnd)
4657 )
4658 );
4659 assert_eq!(
4660 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).animationLast as *const _ as usize },
4661 72usize,
4662 concat!(
4663 "Offset of field: ",
4664 stringify!(spTrackEntry),
4665 "::",
4666 stringify!(animationLast)
4667 )
4668 );
4669 assert_eq!(
4670 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).nextAnimationLast as *const _ as usize },
4671 76usize,
4672 concat!(
4673 "Offset of field: ",
4674 stringify!(spTrackEntry),
4675 "::",
4676 stringify!(nextAnimationLast)
4677 )
4678 );
4679 assert_eq!(
4680 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).delay as *const _ as usize },
4681 80usize,
4682 concat!(
4683 "Offset of field: ",
4684 stringify!(spTrackEntry),
4685 "::",
4686 stringify!(delay)
4687 )
4688 );
4689 assert_eq!(
4690 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).trackTime as *const _ as usize },
4691 84usize,
4692 concat!(
4693 "Offset of field: ",
4694 stringify!(spTrackEntry),
4695 "::",
4696 stringify!(trackTime)
4697 )
4698 );
4699 assert_eq!(
4700 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).trackLast as *const _ as usize },
4701 88usize,
4702 concat!(
4703 "Offset of field: ",
4704 stringify!(spTrackEntry),
4705 "::",
4706 stringify!(trackLast)
4707 )
4708 );
4709 assert_eq!(
4710 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).nextTrackLast as *const _ as usize },
4711 92usize,
4712 concat!(
4713 "Offset of field: ",
4714 stringify!(spTrackEntry),
4715 "::",
4716 stringify!(nextTrackLast)
4717 )
4718 );
4719 assert_eq!(
4720 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).trackEnd as *const _ as usize },
4721 96usize,
4722 concat!(
4723 "Offset of field: ",
4724 stringify!(spTrackEntry),
4725 "::",
4726 stringify!(trackEnd)
4727 )
4728 );
4729 assert_eq!(
4730 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).timeScale as *const _ as usize },
4731 100usize,
4732 concat!(
4733 "Offset of field: ",
4734 stringify!(spTrackEntry),
4735 "::",
4736 stringify!(timeScale)
4737 )
4738 );
4739 assert_eq!(
4740 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).alpha as *const _ as usize },
4741 104usize,
4742 concat!(
4743 "Offset of field: ",
4744 stringify!(spTrackEntry),
4745 "::",
4746 stringify!(alpha)
4747 )
4748 );
4749 assert_eq!(
4750 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).mixTime as *const _ as usize },
4751 108usize,
4752 concat!(
4753 "Offset of field: ",
4754 stringify!(spTrackEntry),
4755 "::",
4756 stringify!(mixTime)
4757 )
4758 );
4759 assert_eq!(
4760 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).mixDuration as *const _ as usize },
4761 112usize,
4762 concat!(
4763 "Offset of field: ",
4764 stringify!(spTrackEntry),
4765 "::",
4766 stringify!(mixDuration)
4767 )
4768 );
4769 assert_eq!(
4770 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).interruptAlpha as *const _ as usize },
4771 116usize,
4772 concat!(
4773 "Offset of field: ",
4774 stringify!(spTrackEntry),
4775 "::",
4776 stringify!(interruptAlpha)
4777 )
4778 );
4779 assert_eq!(
4780 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).totalAlpha as *const _ as usize },
4781 120usize,
4782 concat!(
4783 "Offset of field: ",
4784 stringify!(spTrackEntry),
4785 "::",
4786 stringify!(totalAlpha)
4787 )
4788 );
4789 assert_eq!(
4790 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).mixBlend as *const _ as usize },
4791 124usize,
4792 concat!(
4793 "Offset of field: ",
4794 stringify!(spTrackEntry),
4795 "::",
4796 stringify!(mixBlend)
4797 )
4798 );
4799 assert_eq!(
4800 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).timelineMode as *const _ as usize },
4801 128usize,
4802 concat!(
4803 "Offset of field: ",
4804 stringify!(spTrackEntry),
4805 "::",
4806 stringify!(timelineMode)
4807 )
4808 );
4809 assert_eq!(
4810 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).timelineHoldMix as *const _ as usize },
4811 136usize,
4812 concat!(
4813 "Offset of field: ",
4814 stringify!(spTrackEntry),
4815 "::",
4816 stringify!(timelineHoldMix)
4817 )
4818 );
4819 assert_eq!(
4820 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).timelinesRotation as *const _ as usize },
4821 144usize,
4822 concat!(
4823 "Offset of field: ",
4824 stringify!(spTrackEntry),
4825 "::",
4826 stringify!(timelinesRotation)
4827 )
4828 );
4829 assert_eq!(
4830 unsafe {
4831 &(*(::std::ptr::null::<spTrackEntry>())).timelinesRotationCount as *const _ as usize
4832 },
4833 152usize,
4834 concat!(
4835 "Offset of field: ",
4836 stringify!(spTrackEntry),
4837 "::",
4838 stringify!(timelinesRotationCount)
4839 )
4840 );
4841 assert_eq!(
4842 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).rendererObject as *const _ as usize },
4843 160usize,
4844 concat!(
4845 "Offset of field: ",
4846 stringify!(spTrackEntry),
4847 "::",
4848 stringify!(rendererObject)
4849 )
4850 );
4851 assert_eq!(
4852 unsafe { &(*(::std::ptr::null::<spTrackEntry>())).userData as *const _ as usize },
4853 168usize,
4854 concat!(
4855 "Offset of field: ",
4856 stringify!(spTrackEntry),
4857 "::",
4858 stringify!(userData)
4859 )
4860 );
4861}
4862#[repr(C)]
4863#[derive(Debug, Copy, Clone)]
4864pub struct spAnimationState {
4865 pub data: *mut spAnimationStateData,
4866 pub tracksCount: ::std::os::raw::c_int,
4867 pub tracks: *mut *mut spTrackEntry,
4868 pub listener: spAnimationStateListener,
4869 pub timeScale: f32,
4870 pub rendererObject: *mut ::std::os::raw::c_void,
4871 pub userData: *mut ::std::os::raw::c_void,
4872}
4873#[test]
4874fn bindgen_test_layout_spAnimationState() {
4875 assert_eq!(
4876 ::std::mem::size_of::<spAnimationState>(),
4877 56usize,
4878 concat!("Size of: ", stringify!(spAnimationState))
4879 );
4880 assert_eq!(
4881 ::std::mem::align_of::<spAnimationState>(),
4882 8usize,
4883 concat!("Alignment of ", stringify!(spAnimationState))
4884 );
4885 assert_eq!(
4886 unsafe { &(*(::std::ptr::null::<spAnimationState>())).data as *const _ as usize },
4887 0usize,
4888 concat!(
4889 "Offset of field: ",
4890 stringify!(spAnimationState),
4891 "::",
4892 stringify!(data)
4893 )
4894 );
4895 assert_eq!(
4896 unsafe { &(*(::std::ptr::null::<spAnimationState>())).tracksCount as *const _ as usize },
4897 8usize,
4898 concat!(
4899 "Offset of field: ",
4900 stringify!(spAnimationState),
4901 "::",
4902 stringify!(tracksCount)
4903 )
4904 );
4905 assert_eq!(
4906 unsafe { &(*(::std::ptr::null::<spAnimationState>())).tracks as *const _ as usize },
4907 16usize,
4908 concat!(
4909 "Offset of field: ",
4910 stringify!(spAnimationState),
4911 "::",
4912 stringify!(tracks)
4913 )
4914 );
4915 assert_eq!(
4916 unsafe { &(*(::std::ptr::null::<spAnimationState>())).listener as *const _ as usize },
4917 24usize,
4918 concat!(
4919 "Offset of field: ",
4920 stringify!(spAnimationState),
4921 "::",
4922 stringify!(listener)
4923 )
4924 );
4925 assert_eq!(
4926 unsafe { &(*(::std::ptr::null::<spAnimationState>())).timeScale as *const _ as usize },
4927 32usize,
4928 concat!(
4929 "Offset of field: ",
4930 stringify!(spAnimationState),
4931 "::",
4932 stringify!(timeScale)
4933 )
4934 );
4935 assert_eq!(
4936 unsafe { &(*(::std::ptr::null::<spAnimationState>())).rendererObject as *const _ as usize },
4937 40usize,
4938 concat!(
4939 "Offset of field: ",
4940 stringify!(spAnimationState),
4941 "::",
4942 stringify!(rendererObject)
4943 )
4944 );
4945 assert_eq!(
4946 unsafe { &(*(::std::ptr::null::<spAnimationState>())).userData as *const _ as usize },
4947 48usize,
4948 concat!(
4949 "Offset of field: ",
4950 stringify!(spAnimationState),
4951 "::",
4952 stringify!(userData)
4953 )
4954 );
4955}
4956extern "C" {
4957 pub fn spAnimationState_create(data: *mut spAnimationStateData) -> *mut spAnimationState;
4958}
4959extern "C" {
4960 pub fn spAnimationState_dispose(self_: *mut spAnimationState);
4961}
4962extern "C" {
4963 pub fn spAnimationState_update(self_: *mut spAnimationState, delta: f32);
4964}
4965extern "C" {
4966 #[doc = "bool"]
4967 pub fn spAnimationState_apply(
4968 self_: *mut spAnimationState,
4969 skeleton: *mut spSkeleton,
4970 ) -> ::std::os::raw::c_int;
4971}
4972extern "C" {
4973 pub fn spAnimationState_clearTracks(self_: *mut spAnimationState);
4974}
4975extern "C" {
4976 pub fn spAnimationState_clearTrack(
4977 self_: *mut spAnimationState,
4978 trackIndex: ::std::os::raw::c_int,
4979 );
4980}
4981extern "C" {
4982 #[doc = " Set the current animation. Any queued animations are cleared."]
4983 pub fn spAnimationState_setAnimationByName(
4984 self_: *mut spAnimationState,
4985 trackIndex: ::std::os::raw::c_int,
4986 animationName: *const ::std::os::raw::c_char,
4987 loop_: ::std::os::raw::c_int,
4988 ) -> *mut spTrackEntry;
4989}
4990extern "C" {
4991 pub fn spAnimationState_setAnimation(
4992 self_: *mut spAnimationState,
4993 trackIndex: ::std::os::raw::c_int,
4994 animation: *mut spAnimation,
4995 loop_: ::std::os::raw::c_int,
4996 ) -> *mut spTrackEntry;
4997}
4998extern "C" {
4999 #[doc = " Adds an animation to be played delay seconds after the current or last queued animation, taking into account any mix"]
5000 #[doc = " duration."]
5001 pub fn spAnimationState_addAnimationByName(
5002 self_: *mut spAnimationState,
5003 trackIndex: ::std::os::raw::c_int,
5004 animationName: *const ::std::os::raw::c_char,
5005 loop_: ::std::os::raw::c_int,
5006 delay: f32,
5007 ) -> *mut spTrackEntry;
5008}
5009extern "C" {
5010 pub fn spAnimationState_addAnimation(
5011 self_: *mut spAnimationState,
5012 trackIndex: ::std::os::raw::c_int,
5013 animation: *mut spAnimation,
5014 loop_: ::std::os::raw::c_int,
5015 delay: f32,
5016 ) -> *mut spTrackEntry;
5017}
5018extern "C" {
5019 pub fn spAnimationState_setEmptyAnimation(
5020 self_: *mut spAnimationState,
5021 trackIndex: ::std::os::raw::c_int,
5022 mixDuration: f32,
5023 ) -> *mut spTrackEntry;
5024}
5025extern "C" {
5026 pub fn spAnimationState_addEmptyAnimation(
5027 self_: *mut spAnimationState,
5028 trackIndex: ::std::os::raw::c_int,
5029 mixDuration: f32,
5030 delay: f32,
5031 ) -> *mut spTrackEntry;
5032}
5033extern "C" {
5034 pub fn spAnimationState_setEmptyAnimations(self_: *mut spAnimationState, mixDuration: f32);
5035}
5036extern "C" {
5037 pub fn spAnimationState_getCurrent(
5038 self_: *mut spAnimationState,
5039 trackIndex: ::std::os::raw::c_int,
5040 ) -> *mut spTrackEntry;
5041}
5042extern "C" {
5043 pub fn spAnimationState_clearListenerNotifications(self_: *mut spAnimationState);
5044}
5045extern "C" {
5046 pub fn spTrackEntry_getAnimationTime(entry: *mut spTrackEntry) -> f32;
5047}
5048extern "C" {
5049 #[doc = " Use this to dispose static memory before your app exits to appease your memory leak detector"]
5050 pub fn spAnimationState_disposeStatics();
5051}
5052pub const spAtlasFormat_SP_ATLAS_UNKNOWN_FORMAT: spAtlasFormat = 0;
5053pub const spAtlasFormat_SP_ATLAS_ALPHA: spAtlasFormat = 1;
5054pub const spAtlasFormat_SP_ATLAS_INTENSITY: spAtlasFormat = 2;
5055pub const spAtlasFormat_SP_ATLAS_LUMINANCE_ALPHA: spAtlasFormat = 3;
5056pub const spAtlasFormat_SP_ATLAS_RGB565: spAtlasFormat = 4;
5057pub const spAtlasFormat_SP_ATLAS_RGBA4444: spAtlasFormat = 5;
5058pub const spAtlasFormat_SP_ATLAS_RGB888: spAtlasFormat = 6;
5059pub const spAtlasFormat_SP_ATLAS_RGBA8888: spAtlasFormat = 7;
5060pub type spAtlasFormat = u32;
5061pub const spAtlasFilter_SP_ATLAS_UNKNOWN_FILTER: spAtlasFilter = 0;
5062pub const spAtlasFilter_SP_ATLAS_NEAREST: spAtlasFilter = 1;
5063pub const spAtlasFilter_SP_ATLAS_LINEAR: spAtlasFilter = 2;
5064pub const spAtlasFilter_SP_ATLAS_MIPMAP: spAtlasFilter = 3;
5065pub const spAtlasFilter_SP_ATLAS_MIPMAP_NEAREST_NEAREST: spAtlasFilter = 4;
5066pub const spAtlasFilter_SP_ATLAS_MIPMAP_LINEAR_NEAREST: spAtlasFilter = 5;
5067pub const spAtlasFilter_SP_ATLAS_MIPMAP_NEAREST_LINEAR: spAtlasFilter = 6;
5068pub const spAtlasFilter_SP_ATLAS_MIPMAP_LINEAR_LINEAR: spAtlasFilter = 7;
5069pub type spAtlasFilter = u32;
5070pub const spAtlasWrap_SP_ATLAS_MIRROREDREPEAT: spAtlasWrap = 0;
5071pub const spAtlasWrap_SP_ATLAS_CLAMPTOEDGE: spAtlasWrap = 1;
5072pub const spAtlasWrap_SP_ATLAS_REPEAT: spAtlasWrap = 2;
5073pub type spAtlasWrap = u32;
5074#[repr(C)]
5075#[derive(Debug, Copy, Clone)]
5076pub struct spAtlasPage {
5077 pub atlas: *const spAtlas,
5078 pub name: *const ::std::os::raw::c_char,
5079 pub format: spAtlasFormat,
5080 pub minFilter: spAtlasFilter,
5081 pub magFilter: spAtlasFilter,
5082 pub uWrap: spAtlasWrap,
5083 pub vWrap: spAtlasWrap,
5084 pub rendererObject: *mut ::std::os::raw::c_void,
5085 pub width: ::std::os::raw::c_int,
5086 pub height: ::std::os::raw::c_int,
5087 pub next: *mut spAtlasPage,
5088}
5089#[test]
5090fn bindgen_test_layout_spAtlasPage() {
5091 assert_eq!(
5092 ::std::mem::size_of::<spAtlasPage>(),
5093 64usize,
5094 concat!("Size of: ", stringify!(spAtlasPage))
5095 );
5096 assert_eq!(
5097 ::std::mem::align_of::<spAtlasPage>(),
5098 8usize,
5099 concat!("Alignment of ", stringify!(spAtlasPage))
5100 );
5101 assert_eq!(
5102 unsafe { &(*(::std::ptr::null::<spAtlasPage>())).atlas as *const _ as usize },
5103 0usize,
5104 concat!(
5105 "Offset of field: ",
5106 stringify!(spAtlasPage),
5107 "::",
5108 stringify!(atlas)
5109 )
5110 );
5111 assert_eq!(
5112 unsafe { &(*(::std::ptr::null::<spAtlasPage>())).name as *const _ as usize },
5113 8usize,
5114 concat!(
5115 "Offset of field: ",
5116 stringify!(spAtlasPage),
5117 "::",
5118 stringify!(name)
5119 )
5120 );
5121 assert_eq!(
5122 unsafe { &(*(::std::ptr::null::<spAtlasPage>())).format as *const _ as usize },
5123 16usize,
5124 concat!(
5125 "Offset of field: ",
5126 stringify!(spAtlasPage),
5127 "::",
5128 stringify!(format)
5129 )
5130 );
5131 assert_eq!(
5132 unsafe { &(*(::std::ptr::null::<spAtlasPage>())).minFilter as *const _ as usize },
5133 20usize,
5134 concat!(
5135 "Offset of field: ",
5136 stringify!(spAtlasPage),
5137 "::",
5138 stringify!(minFilter)
5139 )
5140 );
5141 assert_eq!(
5142 unsafe { &(*(::std::ptr::null::<spAtlasPage>())).magFilter as *const _ as usize },
5143 24usize,
5144 concat!(
5145 "Offset of field: ",
5146 stringify!(spAtlasPage),
5147 "::",
5148 stringify!(magFilter)
5149 )
5150 );
5151 assert_eq!(
5152 unsafe { &(*(::std::ptr::null::<spAtlasPage>())).uWrap as *const _ as usize },
5153 28usize,
5154 concat!(
5155 "Offset of field: ",
5156 stringify!(spAtlasPage),
5157 "::",
5158 stringify!(uWrap)
5159 )
5160 );
5161 assert_eq!(
5162 unsafe { &(*(::std::ptr::null::<spAtlasPage>())).vWrap as *const _ as usize },
5163 32usize,
5164 concat!(
5165 "Offset of field: ",
5166 stringify!(spAtlasPage),
5167 "::",
5168 stringify!(vWrap)
5169 )
5170 );
5171 assert_eq!(
5172 unsafe { &(*(::std::ptr::null::<spAtlasPage>())).rendererObject as *const _ as usize },
5173 40usize,
5174 concat!(
5175 "Offset of field: ",
5176 stringify!(spAtlasPage),
5177 "::",
5178 stringify!(rendererObject)
5179 )
5180 );
5181 assert_eq!(
5182 unsafe { &(*(::std::ptr::null::<spAtlasPage>())).width as *const _ as usize },
5183 48usize,
5184 concat!(
5185 "Offset of field: ",
5186 stringify!(spAtlasPage),
5187 "::",
5188 stringify!(width)
5189 )
5190 );
5191 assert_eq!(
5192 unsafe { &(*(::std::ptr::null::<spAtlasPage>())).height as *const _ as usize },
5193 52usize,
5194 concat!(
5195 "Offset of field: ",
5196 stringify!(spAtlasPage),
5197 "::",
5198 stringify!(height)
5199 )
5200 );
5201 assert_eq!(
5202 unsafe { &(*(::std::ptr::null::<spAtlasPage>())).next as *const _ as usize },
5203 56usize,
5204 concat!(
5205 "Offset of field: ",
5206 stringify!(spAtlasPage),
5207 "::",
5208 stringify!(next)
5209 )
5210 );
5211}
5212extern "C" {
5213 pub fn spAtlasPage_create(
5214 atlas: *mut spAtlas,
5215 name: *const ::std::os::raw::c_char,
5216 ) -> *mut spAtlasPage;
5217}
5218extern "C" {
5219 pub fn spAtlasPage_dispose(self_: *mut spAtlasPage);
5220}
5221#[repr(C)]
5222#[derive(Debug, Copy, Clone)]
5223pub struct spAtlasRegion {
5224 pub name: *const ::std::os::raw::c_char,
5225 pub x: ::std::os::raw::c_int,
5226 pub y: ::std::os::raw::c_int,
5227 pub width: ::std::os::raw::c_int,
5228 pub height: ::std::os::raw::c_int,
5229 pub u: f32,
5230 pub v: f32,
5231 pub u2: f32,
5232 pub v2: f32,
5233 pub offsetX: ::std::os::raw::c_int,
5234 pub offsetY: ::std::os::raw::c_int,
5235 pub originalWidth: ::std::os::raw::c_int,
5236 pub originalHeight: ::std::os::raw::c_int,
5237 pub index: ::std::os::raw::c_int,
5238 pub rotate: ::std::os::raw::c_int,
5239 pub degrees: ::std::os::raw::c_int,
5240 pub flip: ::std::os::raw::c_int,
5241 pub splits: *mut ::std::os::raw::c_int,
5242 pub pads: *mut ::std::os::raw::c_int,
5243 pub page: *mut spAtlasPage,
5244 pub next: *mut spAtlasRegion,
5245}
5246#[test]
5247fn bindgen_test_layout_spAtlasRegion() {
5248 assert_eq!(
5249 ::std::mem::size_of::<spAtlasRegion>(),
5250 104usize,
5251 concat!("Size of: ", stringify!(spAtlasRegion))
5252 );
5253 assert_eq!(
5254 ::std::mem::align_of::<spAtlasRegion>(),
5255 8usize,
5256 concat!("Alignment of ", stringify!(spAtlasRegion))
5257 );
5258 assert_eq!(
5259 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).name as *const _ as usize },
5260 0usize,
5261 concat!(
5262 "Offset of field: ",
5263 stringify!(spAtlasRegion),
5264 "::",
5265 stringify!(name)
5266 )
5267 );
5268 assert_eq!(
5269 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).x as *const _ as usize },
5270 8usize,
5271 concat!(
5272 "Offset of field: ",
5273 stringify!(spAtlasRegion),
5274 "::",
5275 stringify!(x)
5276 )
5277 );
5278 assert_eq!(
5279 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).y as *const _ as usize },
5280 12usize,
5281 concat!(
5282 "Offset of field: ",
5283 stringify!(spAtlasRegion),
5284 "::",
5285 stringify!(y)
5286 )
5287 );
5288 assert_eq!(
5289 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).width as *const _ as usize },
5290 16usize,
5291 concat!(
5292 "Offset of field: ",
5293 stringify!(spAtlasRegion),
5294 "::",
5295 stringify!(width)
5296 )
5297 );
5298 assert_eq!(
5299 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).height as *const _ as usize },
5300 20usize,
5301 concat!(
5302 "Offset of field: ",
5303 stringify!(spAtlasRegion),
5304 "::",
5305 stringify!(height)
5306 )
5307 );
5308 assert_eq!(
5309 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).u as *const _ as usize },
5310 24usize,
5311 concat!(
5312 "Offset of field: ",
5313 stringify!(spAtlasRegion),
5314 "::",
5315 stringify!(u)
5316 )
5317 );
5318 assert_eq!(
5319 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).v as *const _ as usize },
5320 28usize,
5321 concat!(
5322 "Offset of field: ",
5323 stringify!(spAtlasRegion),
5324 "::",
5325 stringify!(v)
5326 )
5327 );
5328 assert_eq!(
5329 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).u2 as *const _ as usize },
5330 32usize,
5331 concat!(
5332 "Offset of field: ",
5333 stringify!(spAtlasRegion),
5334 "::",
5335 stringify!(u2)
5336 )
5337 );
5338 assert_eq!(
5339 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).v2 as *const _ as usize },
5340 36usize,
5341 concat!(
5342 "Offset of field: ",
5343 stringify!(spAtlasRegion),
5344 "::",
5345 stringify!(v2)
5346 )
5347 );
5348 assert_eq!(
5349 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).offsetX as *const _ as usize },
5350 40usize,
5351 concat!(
5352 "Offset of field: ",
5353 stringify!(spAtlasRegion),
5354 "::",
5355 stringify!(offsetX)
5356 )
5357 );
5358 assert_eq!(
5359 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).offsetY as *const _ as usize },
5360 44usize,
5361 concat!(
5362 "Offset of field: ",
5363 stringify!(spAtlasRegion),
5364 "::",
5365 stringify!(offsetY)
5366 )
5367 );
5368 assert_eq!(
5369 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).originalWidth as *const _ as usize },
5370 48usize,
5371 concat!(
5372 "Offset of field: ",
5373 stringify!(spAtlasRegion),
5374 "::",
5375 stringify!(originalWidth)
5376 )
5377 );
5378 assert_eq!(
5379 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).originalHeight as *const _ as usize },
5380 52usize,
5381 concat!(
5382 "Offset of field: ",
5383 stringify!(spAtlasRegion),
5384 "::",
5385 stringify!(originalHeight)
5386 )
5387 );
5388 assert_eq!(
5389 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).index as *const _ as usize },
5390 56usize,
5391 concat!(
5392 "Offset of field: ",
5393 stringify!(spAtlasRegion),
5394 "::",
5395 stringify!(index)
5396 )
5397 );
5398 assert_eq!(
5399 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).rotate as *const _ as usize },
5400 60usize,
5401 concat!(
5402 "Offset of field: ",
5403 stringify!(spAtlasRegion),
5404 "::",
5405 stringify!(rotate)
5406 )
5407 );
5408 assert_eq!(
5409 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).degrees as *const _ as usize },
5410 64usize,
5411 concat!(
5412 "Offset of field: ",
5413 stringify!(spAtlasRegion),
5414 "::",
5415 stringify!(degrees)
5416 )
5417 );
5418 assert_eq!(
5419 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).flip as *const _ as usize },
5420 68usize,
5421 concat!(
5422 "Offset of field: ",
5423 stringify!(spAtlasRegion),
5424 "::",
5425 stringify!(flip)
5426 )
5427 );
5428 assert_eq!(
5429 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).splits as *const _ as usize },
5430 72usize,
5431 concat!(
5432 "Offset of field: ",
5433 stringify!(spAtlasRegion),
5434 "::",
5435 stringify!(splits)
5436 )
5437 );
5438 assert_eq!(
5439 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).pads as *const _ as usize },
5440 80usize,
5441 concat!(
5442 "Offset of field: ",
5443 stringify!(spAtlasRegion),
5444 "::",
5445 stringify!(pads)
5446 )
5447 );
5448 assert_eq!(
5449 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).page as *const _ as usize },
5450 88usize,
5451 concat!(
5452 "Offset of field: ",
5453 stringify!(spAtlasRegion),
5454 "::",
5455 stringify!(page)
5456 )
5457 );
5458 assert_eq!(
5459 unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).next as *const _ as usize },
5460 96usize,
5461 concat!(
5462 "Offset of field: ",
5463 stringify!(spAtlasRegion),
5464 "::",
5465 stringify!(next)
5466 )
5467 );
5468}
5469extern "C" {
5470 pub fn spAtlasRegion_create() -> *mut spAtlasRegion;
5471}
5472extern "C" {
5473 pub fn spAtlasRegion_dispose(self_: *mut spAtlasRegion);
5474}
5475#[repr(C)]
5476#[derive(Debug, Copy, Clone)]
5477pub struct spAtlas {
5478 pub pages: *mut spAtlasPage,
5479 pub regions: *mut spAtlasRegion,
5480 pub rendererObject: *mut ::std::os::raw::c_void,
5481}
5482#[test]
5483fn bindgen_test_layout_spAtlas() {
5484 assert_eq!(
5485 ::std::mem::size_of::<spAtlas>(),
5486 24usize,
5487 concat!("Size of: ", stringify!(spAtlas))
5488 );
5489 assert_eq!(
5490 ::std::mem::align_of::<spAtlas>(),
5491 8usize,
5492 concat!("Alignment of ", stringify!(spAtlas))
5493 );
5494 assert_eq!(
5495 unsafe { &(*(::std::ptr::null::<spAtlas>())).pages as *const _ as usize },
5496 0usize,
5497 concat!(
5498 "Offset of field: ",
5499 stringify!(spAtlas),
5500 "::",
5501 stringify!(pages)
5502 )
5503 );
5504 assert_eq!(
5505 unsafe { &(*(::std::ptr::null::<spAtlas>())).regions as *const _ as usize },
5506 8usize,
5507 concat!(
5508 "Offset of field: ",
5509 stringify!(spAtlas),
5510 "::",
5511 stringify!(regions)
5512 )
5513 );
5514 assert_eq!(
5515 unsafe { &(*(::std::ptr::null::<spAtlas>())).rendererObject as *const _ as usize },
5516 16usize,
5517 concat!(
5518 "Offset of field: ",
5519 stringify!(spAtlas),
5520 "::",
5521 stringify!(rendererObject)
5522 )
5523 );
5524}
5525extern "C" {
5526 pub fn spAtlas_create(
5527 data: *const ::std::os::raw::c_char,
5528 length: ::std::os::raw::c_int,
5529 dir: *const ::std::os::raw::c_char,
5530 rendererObject: *mut ::std::os::raw::c_void,
5531 ) -> *mut spAtlas;
5532}
5533extern "C" {
5534 pub fn spAtlas_createFromFile(
5535 path: *const ::std::os::raw::c_char,
5536 rendererObject: *mut ::std::os::raw::c_void,
5537 ) -> *mut spAtlas;
5538}
5539extern "C" {
5540 pub fn spAtlas_dispose(atlas: *mut spAtlas);
5541}
5542extern "C" {
5543 pub fn spAtlas_findRegion(
5544 self_: *const spAtlas,
5545 name: *const ::std::os::raw::c_char,
5546 ) -> *mut spAtlasRegion;
5547}
5548#[repr(C)]
5549#[derive(Debug, Copy, Clone)]
5550pub struct spAttachmentLoader {
5551 pub error1: *const ::std::os::raw::c_char,
5552 pub error2: *const ::std::os::raw::c_char,
5553 pub vtable: *const ::std::os::raw::c_void,
5554}
5555#[test]
5556fn bindgen_test_layout_spAttachmentLoader() {
5557 assert_eq!(
5558 ::std::mem::size_of::<spAttachmentLoader>(),
5559 24usize,
5560 concat!("Size of: ", stringify!(spAttachmentLoader))
5561 );
5562 assert_eq!(
5563 ::std::mem::align_of::<spAttachmentLoader>(),
5564 8usize,
5565 concat!("Alignment of ", stringify!(spAttachmentLoader))
5566 );
5567 assert_eq!(
5568 unsafe { &(*(::std::ptr::null::<spAttachmentLoader>())).error1 as *const _ as usize },
5569 0usize,
5570 concat!(
5571 "Offset of field: ",
5572 stringify!(spAttachmentLoader),
5573 "::",
5574 stringify!(error1)
5575 )
5576 );
5577 assert_eq!(
5578 unsafe { &(*(::std::ptr::null::<spAttachmentLoader>())).error2 as *const _ as usize },
5579 8usize,
5580 concat!(
5581 "Offset of field: ",
5582 stringify!(spAttachmentLoader),
5583 "::",
5584 stringify!(error2)
5585 )
5586 );
5587 assert_eq!(
5588 unsafe { &(*(::std::ptr::null::<spAttachmentLoader>())).vtable as *const _ as usize },
5589 16usize,
5590 concat!(
5591 "Offset of field: ",
5592 stringify!(spAttachmentLoader),
5593 "::",
5594 stringify!(vtable)
5595 )
5596 );
5597}
5598extern "C" {
5599 pub fn spAttachmentLoader_dispose(self_: *mut spAttachmentLoader);
5600}
5601extern "C" {
5602 pub fn spAttachmentLoader_createAttachment(
5603 self_: *mut spAttachmentLoader,
5604 skin: *mut spSkin,
5605 type_: spAttachmentType,
5606 name: *const ::std::os::raw::c_char,
5607 path: *const ::std::os::raw::c_char,
5608 ) -> *mut spAttachment;
5609}
5610extern "C" {
5611 pub fn spAttachmentLoader_configureAttachment(
5612 self_: *mut spAttachmentLoader,
5613 attachment: *mut spAttachment,
5614 );
5615}
5616extern "C" {
5617 pub fn spAttachmentLoader_disposeAttachment(
5618 self_: *mut spAttachmentLoader,
5619 attachment: *mut spAttachment,
5620 );
5621}
5622#[repr(C)]
5623#[derive(Debug, Copy, Clone)]
5624pub struct spAtlasAttachmentLoader {
5625 pub super_: spAttachmentLoader,
5626 pub atlas: *mut spAtlas,
5627}
5628#[test]
5629fn bindgen_test_layout_spAtlasAttachmentLoader() {
5630 assert_eq!(
5631 ::std::mem::size_of::<spAtlasAttachmentLoader>(),
5632 32usize,
5633 concat!("Size of: ", stringify!(spAtlasAttachmentLoader))
5634 );
5635 assert_eq!(
5636 ::std::mem::align_of::<spAtlasAttachmentLoader>(),
5637 8usize,
5638 concat!("Alignment of ", stringify!(spAtlasAttachmentLoader))
5639 );
5640 assert_eq!(
5641 unsafe { &(*(::std::ptr::null::<spAtlasAttachmentLoader>())).super_ as *const _ as usize },
5642 0usize,
5643 concat!(
5644 "Offset of field: ",
5645 stringify!(spAtlasAttachmentLoader),
5646 "::",
5647 stringify!(super_)
5648 )
5649 );
5650 assert_eq!(
5651 unsafe { &(*(::std::ptr::null::<spAtlasAttachmentLoader>())).atlas as *const _ as usize },
5652 24usize,
5653 concat!(
5654 "Offset of field: ",
5655 stringify!(spAtlasAttachmentLoader),
5656 "::",
5657 stringify!(atlas)
5658 )
5659 );
5660}
5661extern "C" {
5662 pub fn spAtlasAttachmentLoader_create(atlas: *mut spAtlas) -> *mut spAtlasAttachmentLoader;
5663}
5664#[repr(C)]
5665#[derive(Debug, Copy, Clone)]
5666pub struct spBone {
5667 pub data: *mut spBoneData,
5668 pub skeleton: *mut spSkeleton,
5669 pub parent: *mut spBone,
5670 pub childrenCount: ::std::os::raw::c_int,
5671 pub children: *mut *mut spBone,
5672 pub x: f32,
5673 pub y: f32,
5674 pub rotation: f32,
5675 pub scaleX: f32,
5676 pub scaleY: f32,
5677 pub shearX: f32,
5678 pub shearY: f32,
5679 pub ax: f32,
5680 pub ay: f32,
5681 pub arotation: f32,
5682 pub ascaleX: f32,
5683 pub ascaleY: f32,
5684 pub ashearX: f32,
5685 pub ashearY: f32,
5686 pub appliedValid: ::std::os::raw::c_int,
5687 pub a: f32,
5688 pub b: f32,
5689 pub worldX: f32,
5690 pub c: f32,
5691 pub d: f32,
5692 pub worldY: f32,
5693 pub sorted: ::std::os::raw::c_int,
5694 pub active: ::std::os::raw::c_int,
5695}
5696#[test]
5697fn bindgen_test_layout_spBone() {
5698 assert_eq!(
5699 ::std::mem::size_of::<spBone>(),
5700 136usize,
5701 concat!("Size of: ", stringify!(spBone))
5702 );
5703 assert_eq!(
5704 ::std::mem::align_of::<spBone>(),
5705 8usize,
5706 concat!("Alignment of ", stringify!(spBone))
5707 );
5708 assert_eq!(
5709 unsafe { &(*(::std::ptr::null::<spBone>())).data as *const _ as usize },
5710 0usize,
5711 concat!(
5712 "Offset of field: ",
5713 stringify!(spBone),
5714 "::",
5715 stringify!(data)
5716 )
5717 );
5718 assert_eq!(
5719 unsafe { &(*(::std::ptr::null::<spBone>())).skeleton as *const _ as usize },
5720 8usize,
5721 concat!(
5722 "Offset of field: ",
5723 stringify!(spBone),
5724 "::",
5725 stringify!(skeleton)
5726 )
5727 );
5728 assert_eq!(
5729 unsafe { &(*(::std::ptr::null::<spBone>())).parent as *const _ as usize },
5730 16usize,
5731 concat!(
5732 "Offset of field: ",
5733 stringify!(spBone),
5734 "::",
5735 stringify!(parent)
5736 )
5737 );
5738 assert_eq!(
5739 unsafe { &(*(::std::ptr::null::<spBone>())).childrenCount as *const _ as usize },
5740 24usize,
5741 concat!(
5742 "Offset of field: ",
5743 stringify!(spBone),
5744 "::",
5745 stringify!(childrenCount)
5746 )
5747 );
5748 assert_eq!(
5749 unsafe { &(*(::std::ptr::null::<spBone>())).children as *const _ as usize },
5750 32usize,
5751 concat!(
5752 "Offset of field: ",
5753 stringify!(spBone),
5754 "::",
5755 stringify!(children)
5756 )
5757 );
5758 assert_eq!(
5759 unsafe { &(*(::std::ptr::null::<spBone>())).x as *const _ as usize },
5760 40usize,
5761 concat!("Offset of field: ", stringify!(spBone), "::", stringify!(x))
5762 );
5763 assert_eq!(
5764 unsafe { &(*(::std::ptr::null::<spBone>())).y as *const _ as usize },
5765 44usize,
5766 concat!("Offset of field: ", stringify!(spBone), "::", stringify!(y))
5767 );
5768 assert_eq!(
5769 unsafe { &(*(::std::ptr::null::<spBone>())).rotation as *const _ as usize },
5770 48usize,
5771 concat!(
5772 "Offset of field: ",
5773 stringify!(spBone),
5774 "::",
5775 stringify!(rotation)
5776 )
5777 );
5778 assert_eq!(
5779 unsafe { &(*(::std::ptr::null::<spBone>())).scaleX as *const _ as usize },
5780 52usize,
5781 concat!(
5782 "Offset of field: ",
5783 stringify!(spBone),
5784 "::",
5785 stringify!(scaleX)
5786 )
5787 );
5788 assert_eq!(
5789 unsafe { &(*(::std::ptr::null::<spBone>())).scaleY as *const _ as usize },
5790 56usize,
5791 concat!(
5792 "Offset of field: ",
5793 stringify!(spBone),
5794 "::",
5795 stringify!(scaleY)
5796 )
5797 );
5798 assert_eq!(
5799 unsafe { &(*(::std::ptr::null::<spBone>())).shearX as *const _ as usize },
5800 60usize,
5801 concat!(
5802 "Offset of field: ",
5803 stringify!(spBone),
5804 "::",
5805 stringify!(shearX)
5806 )
5807 );
5808 assert_eq!(
5809 unsafe { &(*(::std::ptr::null::<spBone>())).shearY as *const _ as usize },
5810 64usize,
5811 concat!(
5812 "Offset of field: ",
5813 stringify!(spBone),
5814 "::",
5815 stringify!(shearY)
5816 )
5817 );
5818 assert_eq!(
5819 unsafe { &(*(::std::ptr::null::<spBone>())).ax as *const _ as usize },
5820 68usize,
5821 concat!(
5822 "Offset of field: ",
5823 stringify!(spBone),
5824 "::",
5825 stringify!(ax)
5826 )
5827 );
5828 assert_eq!(
5829 unsafe { &(*(::std::ptr::null::<spBone>())).ay as *const _ as usize },
5830 72usize,
5831 concat!(
5832 "Offset of field: ",
5833 stringify!(spBone),
5834 "::",
5835 stringify!(ay)
5836 )
5837 );
5838 assert_eq!(
5839 unsafe { &(*(::std::ptr::null::<spBone>())).arotation as *const _ as usize },
5840 76usize,
5841 concat!(
5842 "Offset of field: ",
5843 stringify!(spBone),
5844 "::",
5845 stringify!(arotation)
5846 )
5847 );
5848 assert_eq!(
5849 unsafe { &(*(::std::ptr::null::<spBone>())).ascaleX as *const _ as usize },
5850 80usize,
5851 concat!(
5852 "Offset of field: ",
5853 stringify!(spBone),
5854 "::",
5855 stringify!(ascaleX)
5856 )
5857 );
5858 assert_eq!(
5859 unsafe { &(*(::std::ptr::null::<spBone>())).ascaleY as *const _ as usize },
5860 84usize,
5861 concat!(
5862 "Offset of field: ",
5863 stringify!(spBone),
5864 "::",
5865 stringify!(ascaleY)
5866 )
5867 );
5868 assert_eq!(
5869 unsafe { &(*(::std::ptr::null::<spBone>())).ashearX as *const _ as usize },
5870 88usize,
5871 concat!(
5872 "Offset of field: ",
5873 stringify!(spBone),
5874 "::",
5875 stringify!(ashearX)
5876 )
5877 );
5878 assert_eq!(
5879 unsafe { &(*(::std::ptr::null::<spBone>())).ashearY as *const _ as usize },
5880 92usize,
5881 concat!(
5882 "Offset of field: ",
5883 stringify!(spBone),
5884 "::",
5885 stringify!(ashearY)
5886 )
5887 );
5888 assert_eq!(
5889 unsafe { &(*(::std::ptr::null::<spBone>())).appliedValid as *const _ as usize },
5890 96usize,
5891 concat!(
5892 "Offset of field: ",
5893 stringify!(spBone),
5894 "::",
5895 stringify!(appliedValid)
5896 )
5897 );
5898 assert_eq!(
5899 unsafe { &(*(::std::ptr::null::<spBone>())).a as *const _ as usize },
5900 100usize,
5901 concat!("Offset of field: ", stringify!(spBone), "::", stringify!(a))
5902 );
5903 assert_eq!(
5904 unsafe { &(*(::std::ptr::null::<spBone>())).b as *const _ as usize },
5905 104usize,
5906 concat!("Offset of field: ", stringify!(spBone), "::", stringify!(b))
5907 );
5908 assert_eq!(
5909 unsafe { &(*(::std::ptr::null::<spBone>())).worldX as *const _ as usize },
5910 108usize,
5911 concat!(
5912 "Offset of field: ",
5913 stringify!(spBone),
5914 "::",
5915 stringify!(worldX)
5916 )
5917 );
5918 assert_eq!(
5919 unsafe { &(*(::std::ptr::null::<spBone>())).c as *const _ as usize },
5920 112usize,
5921 concat!("Offset of field: ", stringify!(spBone), "::", stringify!(c))
5922 );
5923 assert_eq!(
5924 unsafe { &(*(::std::ptr::null::<spBone>())).d as *const _ as usize },
5925 116usize,
5926 concat!("Offset of field: ", stringify!(spBone), "::", stringify!(d))
5927 );
5928 assert_eq!(
5929 unsafe { &(*(::std::ptr::null::<spBone>())).worldY as *const _ as usize },
5930 120usize,
5931 concat!(
5932 "Offset of field: ",
5933 stringify!(spBone),
5934 "::",
5935 stringify!(worldY)
5936 )
5937 );
5938 assert_eq!(
5939 unsafe { &(*(::std::ptr::null::<spBone>())).sorted as *const _ as usize },
5940 124usize,
5941 concat!(
5942 "Offset of field: ",
5943 stringify!(spBone),
5944 "::",
5945 stringify!(sorted)
5946 )
5947 );
5948 assert_eq!(
5949 unsafe { &(*(::std::ptr::null::<spBone>())).active as *const _ as usize },
5950 128usize,
5951 concat!(
5952 "Offset of field: ",
5953 stringify!(spBone),
5954 "::",
5955 stringify!(active)
5956 )
5957 );
5958}
5959extern "C" {
5960 pub fn spBone_setYDown(yDown: ::std::os::raw::c_int);
5961}
5962extern "C" {
5963 pub fn spBone_isYDown() -> ::std::os::raw::c_int;
5964}
5965extern "C" {
5966 pub fn spBone_create(
5967 data: *mut spBoneData,
5968 skeleton: *mut spSkeleton,
5969 parent: *mut spBone,
5970 ) -> *mut spBone;
5971}
5972extern "C" {
5973 pub fn spBone_dispose(self_: *mut spBone);
5974}
5975extern "C" {
5976 pub fn spBone_setToSetupPose(self_: *mut spBone);
5977}
5978extern "C" {
5979 pub fn spBone_updateWorldTransform(self_: *mut spBone);
5980}
5981extern "C" {
5982 pub fn spBone_updateWorldTransformWith(
5983 self_: *mut spBone,
5984 x: f32,
5985 y: f32,
5986 rotation: f32,
5987 scaleX: f32,
5988 scaleY: f32,
5989 shearX: f32,
5990 shearY: f32,
5991 );
5992}
5993extern "C" {
5994 pub fn spBone_getWorldRotationX(self_: *mut spBone) -> f32;
5995}
5996extern "C" {
5997 pub fn spBone_getWorldRotationY(self_: *mut spBone) -> f32;
5998}
5999extern "C" {
6000 pub fn spBone_getWorldScaleX(self_: *mut spBone) -> f32;
6001}
6002extern "C" {
6003 pub fn spBone_getWorldScaleY(self_: *mut spBone) -> f32;
6004}
6005extern "C" {
6006 pub fn spBone_updateAppliedTransform(self_: *mut spBone);
6007}
6008extern "C" {
6009 pub fn spBone_worldToLocal(
6010 self_: *mut spBone,
6011 worldX: f32,
6012 worldY: f32,
6013 localX: *mut f32,
6014 localY: *mut f32,
6015 );
6016}
6017extern "C" {
6018 pub fn spBone_localToWorld(
6019 self_: *mut spBone,
6020 localX: f32,
6021 localY: f32,
6022 worldX: *mut f32,
6023 worldY: *mut f32,
6024 );
6025}
6026extern "C" {
6027 pub fn spBone_worldToLocalRotation(self_: *mut spBone, worldRotation: f32) -> f32;
6028}
6029extern "C" {
6030 pub fn spBone_localToWorldRotation(self_: *mut spBone, localRotation: f32) -> f32;
6031}
6032extern "C" {
6033 pub fn spBone_rotateWorld(self_: *mut spBone, degrees: f32);
6034}
6035#[repr(C)]
6036#[derive(Debug, Copy, Clone)]
6037pub struct spSlot {
6038 pub data: *mut spSlotData,
6039 pub bone: *mut spBone,
6040 pub color: spColor,
6041 pub darkColor: *mut spColor,
6042 pub attachment: *mut spAttachment,
6043 pub deformCapacity: ::std::os::raw::c_int,
6044 pub deformCount: ::std::os::raw::c_int,
6045 pub deform: *mut f32,
6046}
6047#[test]
6048fn bindgen_test_layout_spSlot() {
6049 assert_eq!(
6050 ::std::mem::size_of::<spSlot>(),
6051 64usize,
6052 concat!("Size of: ", stringify!(spSlot))
6053 );
6054 assert_eq!(
6055 ::std::mem::align_of::<spSlot>(),
6056 8usize,
6057 concat!("Alignment of ", stringify!(spSlot))
6058 );
6059 assert_eq!(
6060 unsafe { &(*(::std::ptr::null::<spSlot>())).data as *const _ as usize },
6061 0usize,
6062 concat!(
6063 "Offset of field: ",
6064 stringify!(spSlot),
6065 "::",
6066 stringify!(data)
6067 )
6068 );
6069 assert_eq!(
6070 unsafe { &(*(::std::ptr::null::<spSlot>())).bone as *const _ as usize },
6071 8usize,
6072 concat!(
6073 "Offset of field: ",
6074 stringify!(spSlot),
6075 "::",
6076 stringify!(bone)
6077 )
6078 );
6079 assert_eq!(
6080 unsafe { &(*(::std::ptr::null::<spSlot>())).color as *const _ as usize },
6081 16usize,
6082 concat!(
6083 "Offset of field: ",
6084 stringify!(spSlot),
6085 "::",
6086 stringify!(color)
6087 )
6088 );
6089 assert_eq!(
6090 unsafe { &(*(::std::ptr::null::<spSlot>())).darkColor as *const _ as usize },
6091 32usize,
6092 concat!(
6093 "Offset of field: ",
6094 stringify!(spSlot),
6095 "::",
6096 stringify!(darkColor)
6097 )
6098 );
6099 assert_eq!(
6100 unsafe { &(*(::std::ptr::null::<spSlot>())).attachment as *const _ as usize },
6101 40usize,
6102 concat!(
6103 "Offset of field: ",
6104 stringify!(spSlot),
6105 "::",
6106 stringify!(attachment)
6107 )
6108 );
6109 assert_eq!(
6110 unsafe { &(*(::std::ptr::null::<spSlot>())).deformCapacity as *const _ as usize },
6111 48usize,
6112 concat!(
6113 "Offset of field: ",
6114 stringify!(spSlot),
6115 "::",
6116 stringify!(deformCapacity)
6117 )
6118 );
6119 assert_eq!(
6120 unsafe { &(*(::std::ptr::null::<spSlot>())).deformCount as *const _ as usize },
6121 52usize,
6122 concat!(
6123 "Offset of field: ",
6124 stringify!(spSlot),
6125 "::",
6126 stringify!(deformCount)
6127 )
6128 );
6129 assert_eq!(
6130 unsafe { &(*(::std::ptr::null::<spSlot>())).deform as *const _ as usize },
6131 56usize,
6132 concat!(
6133 "Offset of field: ",
6134 stringify!(spSlot),
6135 "::",
6136 stringify!(deform)
6137 )
6138 );
6139}
6140extern "C" {
6141 pub fn spSlot_create(data: *mut spSlotData, bone: *mut spBone) -> *mut spSlot;
6142}
6143extern "C" {
6144 pub fn spSlot_dispose(self_: *mut spSlot);
6145}
6146extern "C" {
6147 pub fn spSlot_setAttachment(self_: *mut spSlot, attachment: *mut spAttachment);
6148}
6149extern "C" {
6150 pub fn spSlot_setAttachmentTime(self_: *mut spSlot, time: f32);
6151}
6152extern "C" {
6153 pub fn spSlot_getAttachmentTime(self_: *const spSlot) -> f32;
6154}
6155extern "C" {
6156 pub fn spSlot_setToSetupPose(self_: *mut spSlot);
6157}
6158#[repr(C)]
6159#[derive(Debug, Copy, Clone)]
6160pub struct spRegionAttachment {
6161 pub super_: spAttachment,
6162 pub path: *const ::std::os::raw::c_char,
6163 pub x: f32,
6164 pub y: f32,
6165 pub scaleX: f32,
6166 pub scaleY: f32,
6167 pub rotation: f32,
6168 pub width: f32,
6169 pub height: f32,
6170 pub color: spColor,
6171 pub rendererObject: *mut ::std::os::raw::c_void,
6172 pub regionOffsetX: ::std::os::raw::c_int,
6173 pub regionOffsetY: ::std::os::raw::c_int,
6174 pub regionWidth: ::std::os::raw::c_int,
6175 pub regionHeight: ::std::os::raw::c_int,
6176 pub regionOriginalWidth: ::std::os::raw::c_int,
6177 pub regionOriginalHeight: ::std::os::raw::c_int,
6178 pub offset: [f32; 8usize],
6179 pub uvs: [f32; 8usize],
6180}
6181#[test]
6182fn bindgen_test_layout_spRegionAttachment() {
6183 assert_eq!(
6184 ::std::mem::size_of::<spRegionAttachment>(),
6185 192usize,
6186 concat!("Size of: ", stringify!(spRegionAttachment))
6187 );
6188 assert_eq!(
6189 ::std::mem::align_of::<spRegionAttachment>(),
6190 8usize,
6191 concat!("Alignment of ", stringify!(spRegionAttachment))
6192 );
6193 assert_eq!(
6194 unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).super_ as *const _ as usize },
6195 0usize,
6196 concat!(
6197 "Offset of field: ",
6198 stringify!(spRegionAttachment),
6199 "::",
6200 stringify!(super_)
6201 )
6202 );
6203 assert_eq!(
6204 unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).path as *const _ as usize },
6205 40usize,
6206 concat!(
6207 "Offset of field: ",
6208 stringify!(spRegionAttachment),
6209 "::",
6210 stringify!(path)
6211 )
6212 );
6213 assert_eq!(
6214 unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).x as *const _ as usize },
6215 48usize,
6216 concat!(
6217 "Offset of field: ",
6218 stringify!(spRegionAttachment),
6219 "::",
6220 stringify!(x)
6221 )
6222 );
6223 assert_eq!(
6224 unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).y as *const _ as usize },
6225 52usize,
6226 concat!(
6227 "Offset of field: ",
6228 stringify!(spRegionAttachment),
6229 "::",
6230 stringify!(y)
6231 )
6232 );
6233 assert_eq!(
6234 unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).scaleX as *const _ as usize },
6235 56usize,
6236 concat!(
6237 "Offset of field: ",
6238 stringify!(spRegionAttachment),
6239 "::",
6240 stringify!(scaleX)
6241 )
6242 );
6243 assert_eq!(
6244 unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).scaleY as *const _ as usize },
6245 60usize,
6246 concat!(
6247 "Offset of field: ",
6248 stringify!(spRegionAttachment),
6249 "::",
6250 stringify!(scaleY)
6251 )
6252 );
6253 assert_eq!(
6254 unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).rotation as *const _ as usize },
6255 64usize,
6256 concat!(
6257 "Offset of field: ",
6258 stringify!(spRegionAttachment),
6259 "::",
6260 stringify!(rotation)
6261 )
6262 );
6263 assert_eq!(
6264 unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).width as *const _ as usize },
6265 68usize,
6266 concat!(
6267 "Offset of field: ",
6268 stringify!(spRegionAttachment),
6269 "::",
6270 stringify!(width)
6271 )
6272 );
6273 assert_eq!(
6274 unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).height as *const _ as usize },
6275 72usize,
6276 concat!(
6277 "Offset of field: ",
6278 stringify!(spRegionAttachment),
6279 "::",
6280 stringify!(height)
6281 )
6282 );
6283 assert_eq!(
6284 unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).color as *const _ as usize },
6285 76usize,
6286 concat!(
6287 "Offset of field: ",
6288 stringify!(spRegionAttachment),
6289 "::",
6290 stringify!(color)
6291 )
6292 );
6293 assert_eq!(
6294 unsafe {
6295 &(*(::std::ptr::null::<spRegionAttachment>())).rendererObject as *const _ as usize
6296 },
6297 96usize,
6298 concat!(
6299 "Offset of field: ",
6300 stringify!(spRegionAttachment),
6301 "::",
6302 stringify!(rendererObject)
6303 )
6304 );
6305 assert_eq!(
6306 unsafe {
6307 &(*(::std::ptr::null::<spRegionAttachment>())).regionOffsetX as *const _ as usize
6308 },
6309 104usize,
6310 concat!(
6311 "Offset of field: ",
6312 stringify!(spRegionAttachment),
6313 "::",
6314 stringify!(regionOffsetX)
6315 )
6316 );
6317 assert_eq!(
6318 unsafe {
6319 &(*(::std::ptr::null::<spRegionAttachment>())).regionOffsetY as *const _ as usize
6320 },
6321 108usize,
6322 concat!(
6323 "Offset of field: ",
6324 stringify!(spRegionAttachment),
6325 "::",
6326 stringify!(regionOffsetY)
6327 )
6328 );
6329 assert_eq!(
6330 unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).regionWidth as *const _ as usize },
6331 112usize,
6332 concat!(
6333 "Offset of field: ",
6334 stringify!(spRegionAttachment),
6335 "::",
6336 stringify!(regionWidth)
6337 )
6338 );
6339 assert_eq!(
6340 unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).regionHeight as *const _ as usize },
6341 116usize,
6342 concat!(
6343 "Offset of field: ",
6344 stringify!(spRegionAttachment),
6345 "::",
6346 stringify!(regionHeight)
6347 )
6348 );
6349 assert_eq!(
6350 unsafe {
6351 &(*(::std::ptr::null::<spRegionAttachment>())).regionOriginalWidth as *const _ as usize
6352 },
6353 120usize,
6354 concat!(
6355 "Offset of field: ",
6356 stringify!(spRegionAttachment),
6357 "::",
6358 stringify!(regionOriginalWidth)
6359 )
6360 );
6361 assert_eq!(
6362 unsafe {
6363 &(*(::std::ptr::null::<spRegionAttachment>())).regionOriginalHeight as *const _ as usize
6364 },
6365 124usize,
6366 concat!(
6367 "Offset of field: ",
6368 stringify!(spRegionAttachment),
6369 "::",
6370 stringify!(regionOriginalHeight)
6371 )
6372 );
6373 assert_eq!(
6374 unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).offset as *const _ as usize },
6375 128usize,
6376 concat!(
6377 "Offset of field: ",
6378 stringify!(spRegionAttachment),
6379 "::",
6380 stringify!(offset)
6381 )
6382 );
6383 assert_eq!(
6384 unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).uvs as *const _ as usize },
6385 160usize,
6386 concat!(
6387 "Offset of field: ",
6388 stringify!(spRegionAttachment),
6389 "::",
6390 stringify!(uvs)
6391 )
6392 );
6393}
6394extern "C" {
6395 pub fn spRegionAttachment_create(
6396 name: *const ::std::os::raw::c_char,
6397 ) -> *mut spRegionAttachment;
6398}
6399extern "C" {
6400 pub fn spRegionAttachment_setUVs(
6401 self_: *mut spRegionAttachment,
6402 u: f32,
6403 v: f32,
6404 u2: f32,
6405 v2: f32,
6406 rotate: ::std::os::raw::c_int,
6407 );
6408}
6409extern "C" {
6410 pub fn spRegionAttachment_updateOffset(self_: *mut spRegionAttachment);
6411}
6412extern "C" {
6413 pub fn spRegionAttachment_computeWorldVertices(
6414 self_: *mut spRegionAttachment,
6415 bone: *mut spBone,
6416 vertices: *mut f32,
6417 offset: ::std::os::raw::c_int,
6418 stride: ::std::os::raw::c_int,
6419 );
6420}
6421#[repr(C)]
6422#[derive(Debug, Copy, Clone)]
6423pub struct spVertexAttachment {
6424 pub super_: spAttachment,
6425 pub bonesCount: ::std::os::raw::c_int,
6426 pub bones: *mut ::std::os::raw::c_int,
6427 pub verticesCount: ::std::os::raw::c_int,
6428 pub vertices: *mut f32,
6429 pub worldVerticesLength: ::std::os::raw::c_int,
6430 pub deformAttachment: *mut spVertexAttachment,
6431 pub id: ::std::os::raw::c_int,
6432}
6433#[test]
6434fn bindgen_test_layout_spVertexAttachment() {
6435 assert_eq!(
6436 ::std::mem::size_of::<spVertexAttachment>(),
6437 96usize,
6438 concat!("Size of: ", stringify!(spVertexAttachment))
6439 );
6440 assert_eq!(
6441 ::std::mem::align_of::<spVertexAttachment>(),
6442 8usize,
6443 concat!("Alignment of ", stringify!(spVertexAttachment))
6444 );
6445 assert_eq!(
6446 unsafe { &(*(::std::ptr::null::<spVertexAttachment>())).super_ as *const _ as usize },
6447 0usize,
6448 concat!(
6449 "Offset of field: ",
6450 stringify!(spVertexAttachment),
6451 "::",
6452 stringify!(super_)
6453 )
6454 );
6455 assert_eq!(
6456 unsafe { &(*(::std::ptr::null::<spVertexAttachment>())).bonesCount as *const _ as usize },
6457 40usize,
6458 concat!(
6459 "Offset of field: ",
6460 stringify!(spVertexAttachment),
6461 "::",
6462 stringify!(bonesCount)
6463 )
6464 );
6465 assert_eq!(
6466 unsafe { &(*(::std::ptr::null::<spVertexAttachment>())).bones as *const _ as usize },
6467 48usize,
6468 concat!(
6469 "Offset of field: ",
6470 stringify!(spVertexAttachment),
6471 "::",
6472 stringify!(bones)
6473 )
6474 );
6475 assert_eq!(
6476 unsafe {
6477 &(*(::std::ptr::null::<spVertexAttachment>())).verticesCount as *const _ as usize
6478 },
6479 56usize,
6480 concat!(
6481 "Offset of field: ",
6482 stringify!(spVertexAttachment),
6483 "::",
6484 stringify!(verticesCount)
6485 )
6486 );
6487 assert_eq!(
6488 unsafe { &(*(::std::ptr::null::<spVertexAttachment>())).vertices as *const _ as usize },
6489 64usize,
6490 concat!(
6491 "Offset of field: ",
6492 stringify!(spVertexAttachment),
6493 "::",
6494 stringify!(vertices)
6495 )
6496 );
6497 assert_eq!(
6498 unsafe {
6499 &(*(::std::ptr::null::<spVertexAttachment>())).worldVerticesLength as *const _ as usize
6500 },
6501 72usize,
6502 concat!(
6503 "Offset of field: ",
6504 stringify!(spVertexAttachment),
6505 "::",
6506 stringify!(worldVerticesLength)
6507 )
6508 );
6509 assert_eq!(
6510 unsafe {
6511 &(*(::std::ptr::null::<spVertexAttachment>())).deformAttachment as *const _ as usize
6512 },
6513 80usize,
6514 concat!(
6515 "Offset of field: ",
6516 stringify!(spVertexAttachment),
6517 "::",
6518 stringify!(deformAttachment)
6519 )
6520 );
6521 assert_eq!(
6522 unsafe { &(*(::std::ptr::null::<spVertexAttachment>())).id as *const _ as usize },
6523 88usize,
6524 concat!(
6525 "Offset of field: ",
6526 stringify!(spVertexAttachment),
6527 "::",
6528 stringify!(id)
6529 )
6530 );
6531}
6532extern "C" {
6533 pub fn spVertexAttachment_computeWorldVertices(
6534 self_: *mut spVertexAttachment,
6535 slot: *mut spSlot,
6536 start: ::std::os::raw::c_int,
6537 count: ::std::os::raw::c_int,
6538 worldVertices: *mut f32,
6539 offset: ::std::os::raw::c_int,
6540 stride: ::std::os::raw::c_int,
6541 );
6542}
6543extern "C" {
6544 pub fn spVertexAttachment_copyTo(
6545 self_: *mut spVertexAttachment,
6546 other: *mut spVertexAttachment,
6547 );
6548}
6549#[repr(C)]
6550#[derive(Debug, Copy, Clone)]
6551pub struct spMeshAttachment {
6552 pub super_: spVertexAttachment,
6553 pub rendererObject: *mut ::std::os::raw::c_void,
6554 pub regionOffsetX: ::std::os::raw::c_int,
6555 pub regionOffsetY: ::std::os::raw::c_int,
6556 pub regionWidth: ::std::os::raw::c_int,
6557 pub regionHeight: ::std::os::raw::c_int,
6558 pub regionOriginalWidth: ::std::os::raw::c_int,
6559 pub regionOriginalHeight: ::std::os::raw::c_int,
6560 pub regionU: f32,
6561 pub regionV: f32,
6562 pub regionU2: f32,
6563 pub regionV2: f32,
6564 pub regionRotate: ::std::os::raw::c_int,
6565 pub regionDegrees: ::std::os::raw::c_int,
6566 pub path: *const ::std::os::raw::c_char,
6567 pub regionUVs: *mut f32,
6568 pub uvs: *mut f32,
6569 pub trianglesCount: ::std::os::raw::c_int,
6570 pub triangles: *mut ::std::os::raw::c_ushort,
6571 pub color: spColor,
6572 pub hullLength: ::std::os::raw::c_int,
6573 pub parentMesh: *mut spMeshAttachment,
6574 pub edgesCount: ::std::os::raw::c_int,
6575 pub edges: *mut ::std::os::raw::c_int,
6576 pub width: f32,
6577 pub height: f32,
6578}
6579#[test]
6580fn bindgen_test_layout_spMeshAttachment() {
6581 assert_eq!(
6582 ::std::mem::size_of::<spMeshAttachment>(),
6583 248usize,
6584 concat!("Size of: ", stringify!(spMeshAttachment))
6585 );
6586 assert_eq!(
6587 ::std::mem::align_of::<spMeshAttachment>(),
6588 8usize,
6589 concat!("Alignment of ", stringify!(spMeshAttachment))
6590 );
6591 assert_eq!(
6592 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).super_ as *const _ as usize },
6593 0usize,
6594 concat!(
6595 "Offset of field: ",
6596 stringify!(spMeshAttachment),
6597 "::",
6598 stringify!(super_)
6599 )
6600 );
6601 assert_eq!(
6602 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).rendererObject as *const _ as usize },
6603 96usize,
6604 concat!(
6605 "Offset of field: ",
6606 stringify!(spMeshAttachment),
6607 "::",
6608 stringify!(rendererObject)
6609 )
6610 );
6611 assert_eq!(
6612 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionOffsetX as *const _ as usize },
6613 104usize,
6614 concat!(
6615 "Offset of field: ",
6616 stringify!(spMeshAttachment),
6617 "::",
6618 stringify!(regionOffsetX)
6619 )
6620 );
6621 assert_eq!(
6622 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionOffsetY as *const _ as usize },
6623 108usize,
6624 concat!(
6625 "Offset of field: ",
6626 stringify!(spMeshAttachment),
6627 "::",
6628 stringify!(regionOffsetY)
6629 )
6630 );
6631 assert_eq!(
6632 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionWidth as *const _ as usize },
6633 112usize,
6634 concat!(
6635 "Offset of field: ",
6636 stringify!(spMeshAttachment),
6637 "::",
6638 stringify!(regionWidth)
6639 )
6640 );
6641 assert_eq!(
6642 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionHeight as *const _ as usize },
6643 116usize,
6644 concat!(
6645 "Offset of field: ",
6646 stringify!(spMeshAttachment),
6647 "::",
6648 stringify!(regionHeight)
6649 )
6650 );
6651 assert_eq!(
6652 unsafe {
6653 &(*(::std::ptr::null::<spMeshAttachment>())).regionOriginalWidth as *const _ as usize
6654 },
6655 120usize,
6656 concat!(
6657 "Offset of field: ",
6658 stringify!(spMeshAttachment),
6659 "::",
6660 stringify!(regionOriginalWidth)
6661 )
6662 );
6663 assert_eq!(
6664 unsafe {
6665 &(*(::std::ptr::null::<spMeshAttachment>())).regionOriginalHeight as *const _ as usize
6666 },
6667 124usize,
6668 concat!(
6669 "Offset of field: ",
6670 stringify!(spMeshAttachment),
6671 "::",
6672 stringify!(regionOriginalHeight)
6673 )
6674 );
6675 assert_eq!(
6676 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionU as *const _ as usize },
6677 128usize,
6678 concat!(
6679 "Offset of field: ",
6680 stringify!(spMeshAttachment),
6681 "::",
6682 stringify!(regionU)
6683 )
6684 );
6685 assert_eq!(
6686 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionV as *const _ as usize },
6687 132usize,
6688 concat!(
6689 "Offset of field: ",
6690 stringify!(spMeshAttachment),
6691 "::",
6692 stringify!(regionV)
6693 )
6694 );
6695 assert_eq!(
6696 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionU2 as *const _ as usize },
6697 136usize,
6698 concat!(
6699 "Offset of field: ",
6700 stringify!(spMeshAttachment),
6701 "::",
6702 stringify!(regionU2)
6703 )
6704 );
6705 assert_eq!(
6706 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionV2 as *const _ as usize },
6707 140usize,
6708 concat!(
6709 "Offset of field: ",
6710 stringify!(spMeshAttachment),
6711 "::",
6712 stringify!(regionV2)
6713 )
6714 );
6715 assert_eq!(
6716 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionRotate as *const _ as usize },
6717 144usize,
6718 concat!(
6719 "Offset of field: ",
6720 stringify!(spMeshAttachment),
6721 "::",
6722 stringify!(regionRotate)
6723 )
6724 );
6725 assert_eq!(
6726 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionDegrees as *const _ as usize },
6727 148usize,
6728 concat!(
6729 "Offset of field: ",
6730 stringify!(spMeshAttachment),
6731 "::",
6732 stringify!(regionDegrees)
6733 )
6734 );
6735 assert_eq!(
6736 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).path as *const _ as usize },
6737 152usize,
6738 concat!(
6739 "Offset of field: ",
6740 stringify!(spMeshAttachment),
6741 "::",
6742 stringify!(path)
6743 )
6744 );
6745 assert_eq!(
6746 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionUVs as *const _ as usize },
6747 160usize,
6748 concat!(
6749 "Offset of field: ",
6750 stringify!(spMeshAttachment),
6751 "::",
6752 stringify!(regionUVs)
6753 )
6754 );
6755 assert_eq!(
6756 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).uvs as *const _ as usize },
6757 168usize,
6758 concat!(
6759 "Offset of field: ",
6760 stringify!(spMeshAttachment),
6761 "::",
6762 stringify!(uvs)
6763 )
6764 );
6765 assert_eq!(
6766 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).trianglesCount as *const _ as usize },
6767 176usize,
6768 concat!(
6769 "Offset of field: ",
6770 stringify!(spMeshAttachment),
6771 "::",
6772 stringify!(trianglesCount)
6773 )
6774 );
6775 assert_eq!(
6776 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).triangles as *const _ as usize },
6777 184usize,
6778 concat!(
6779 "Offset of field: ",
6780 stringify!(spMeshAttachment),
6781 "::",
6782 stringify!(triangles)
6783 )
6784 );
6785 assert_eq!(
6786 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).color as *const _ as usize },
6787 192usize,
6788 concat!(
6789 "Offset of field: ",
6790 stringify!(spMeshAttachment),
6791 "::",
6792 stringify!(color)
6793 )
6794 );
6795 assert_eq!(
6796 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).hullLength as *const _ as usize },
6797 208usize,
6798 concat!(
6799 "Offset of field: ",
6800 stringify!(spMeshAttachment),
6801 "::",
6802 stringify!(hullLength)
6803 )
6804 );
6805 assert_eq!(
6806 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).parentMesh as *const _ as usize },
6807 216usize,
6808 concat!(
6809 "Offset of field: ",
6810 stringify!(spMeshAttachment),
6811 "::",
6812 stringify!(parentMesh)
6813 )
6814 );
6815 assert_eq!(
6816 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).edgesCount as *const _ as usize },
6817 224usize,
6818 concat!(
6819 "Offset of field: ",
6820 stringify!(spMeshAttachment),
6821 "::",
6822 stringify!(edgesCount)
6823 )
6824 );
6825 assert_eq!(
6826 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).edges as *const _ as usize },
6827 232usize,
6828 concat!(
6829 "Offset of field: ",
6830 stringify!(spMeshAttachment),
6831 "::",
6832 stringify!(edges)
6833 )
6834 );
6835 assert_eq!(
6836 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).width as *const _ as usize },
6837 240usize,
6838 concat!(
6839 "Offset of field: ",
6840 stringify!(spMeshAttachment),
6841 "::",
6842 stringify!(width)
6843 )
6844 );
6845 assert_eq!(
6846 unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).height as *const _ as usize },
6847 244usize,
6848 concat!(
6849 "Offset of field: ",
6850 stringify!(spMeshAttachment),
6851 "::",
6852 stringify!(height)
6853 )
6854 );
6855}
6856extern "C" {
6857 pub fn spMeshAttachment_create(name: *const ::std::os::raw::c_char) -> *mut spMeshAttachment;
6858}
6859extern "C" {
6860 pub fn spMeshAttachment_updateUVs(self_: *mut spMeshAttachment);
6861}
6862extern "C" {
6863 pub fn spMeshAttachment_setParentMesh(
6864 self_: *mut spMeshAttachment,
6865 parentMesh: *mut spMeshAttachment,
6866 );
6867}
6868extern "C" {
6869 pub fn spMeshAttachment_newLinkedMesh(self_: *mut spMeshAttachment) -> *mut spMeshAttachment;
6870}
6871#[repr(C)]
6872#[derive(Debug, Copy, Clone)]
6873pub struct spBoundingBoxAttachment {
6874 pub super_: spVertexAttachment,
6875}
6876#[test]
6877fn bindgen_test_layout_spBoundingBoxAttachment() {
6878 assert_eq!(
6879 ::std::mem::size_of::<spBoundingBoxAttachment>(),
6880 96usize,
6881 concat!("Size of: ", stringify!(spBoundingBoxAttachment))
6882 );
6883 assert_eq!(
6884 ::std::mem::align_of::<spBoundingBoxAttachment>(),
6885 8usize,
6886 concat!("Alignment of ", stringify!(spBoundingBoxAttachment))
6887 );
6888 assert_eq!(
6889 unsafe { &(*(::std::ptr::null::<spBoundingBoxAttachment>())).super_ as *const _ as usize },
6890 0usize,
6891 concat!(
6892 "Offset of field: ",
6893 stringify!(spBoundingBoxAttachment),
6894 "::",
6895 stringify!(super_)
6896 )
6897 );
6898}
6899extern "C" {
6900 pub fn spBoundingBoxAttachment_create(
6901 name: *const ::std::os::raw::c_char,
6902 ) -> *mut spBoundingBoxAttachment;
6903}
6904#[repr(C)]
6905#[derive(Debug, Copy, Clone)]
6906pub struct spClippingAttachment {
6907 pub super_: spVertexAttachment,
6908 pub endSlot: *mut spSlotData,
6909}
6910#[test]
6911fn bindgen_test_layout_spClippingAttachment() {
6912 assert_eq!(
6913 ::std::mem::size_of::<spClippingAttachment>(),
6914 104usize,
6915 concat!("Size of: ", stringify!(spClippingAttachment))
6916 );
6917 assert_eq!(
6918 ::std::mem::align_of::<spClippingAttachment>(),
6919 8usize,
6920 concat!("Alignment of ", stringify!(spClippingAttachment))
6921 );
6922 assert_eq!(
6923 unsafe { &(*(::std::ptr::null::<spClippingAttachment>())).super_ as *const _ as usize },
6924 0usize,
6925 concat!(
6926 "Offset of field: ",
6927 stringify!(spClippingAttachment),
6928 "::",
6929 stringify!(super_)
6930 )
6931 );
6932 assert_eq!(
6933 unsafe { &(*(::std::ptr::null::<spClippingAttachment>())).endSlot as *const _ as usize },
6934 96usize,
6935 concat!(
6936 "Offset of field: ",
6937 stringify!(spClippingAttachment),
6938 "::",
6939 stringify!(endSlot)
6940 )
6941 );
6942}
6943extern "C" {
6944 pub fn _spClippingAttachment_dispose(self_: *mut spAttachment);
6945}
6946extern "C" {
6947 pub fn spClippingAttachment_create(
6948 name: *const ::std::os::raw::c_char,
6949 ) -> *mut spClippingAttachment;
6950}
6951#[repr(C)]
6952#[derive(Debug, Copy, Clone)]
6953pub struct spPointAttachment {
6954 pub super_: spAttachment,
6955 pub x: f32,
6956 pub y: f32,
6957 pub rotation: f32,
6958 pub color: spColor,
6959}
6960#[test]
6961fn bindgen_test_layout_spPointAttachment() {
6962 assert_eq!(
6963 ::std::mem::size_of::<spPointAttachment>(),
6964 72usize,
6965 concat!("Size of: ", stringify!(spPointAttachment))
6966 );
6967 assert_eq!(
6968 ::std::mem::align_of::<spPointAttachment>(),
6969 8usize,
6970 concat!("Alignment of ", stringify!(spPointAttachment))
6971 );
6972 assert_eq!(
6973 unsafe { &(*(::std::ptr::null::<spPointAttachment>())).super_ as *const _ as usize },
6974 0usize,
6975 concat!(
6976 "Offset of field: ",
6977 stringify!(spPointAttachment),
6978 "::",
6979 stringify!(super_)
6980 )
6981 );
6982 assert_eq!(
6983 unsafe { &(*(::std::ptr::null::<spPointAttachment>())).x as *const _ as usize },
6984 40usize,
6985 concat!(
6986 "Offset of field: ",
6987 stringify!(spPointAttachment),
6988 "::",
6989 stringify!(x)
6990 )
6991 );
6992 assert_eq!(
6993 unsafe { &(*(::std::ptr::null::<spPointAttachment>())).y as *const _ as usize },
6994 44usize,
6995 concat!(
6996 "Offset of field: ",
6997 stringify!(spPointAttachment),
6998 "::",
6999 stringify!(y)
7000 )
7001 );
7002 assert_eq!(
7003 unsafe { &(*(::std::ptr::null::<spPointAttachment>())).rotation as *const _ as usize },
7004 48usize,
7005 concat!(
7006 "Offset of field: ",
7007 stringify!(spPointAttachment),
7008 "::",
7009 stringify!(rotation)
7010 )
7011 );
7012 assert_eq!(
7013 unsafe { &(*(::std::ptr::null::<spPointAttachment>())).color as *const _ as usize },
7014 52usize,
7015 concat!(
7016 "Offset of field: ",
7017 stringify!(spPointAttachment),
7018 "::",
7019 stringify!(color)
7020 )
7021 );
7022}
7023extern "C" {
7024 pub fn spPointAttachment_create(name: *const ::std::os::raw::c_char) -> *mut spPointAttachment;
7025}
7026extern "C" {
7027 pub fn spPointAttachment_computeWorldPosition(
7028 self_: *mut spPointAttachment,
7029 bone: *mut spBone,
7030 x: *mut f32,
7031 y: *mut f32,
7032 );
7033}
7034extern "C" {
7035 pub fn spPointAttachment_computeWorldRotation(
7036 self_: *mut spPointAttachment,
7037 bone: *mut spBone,
7038 ) -> f32;
7039}
7040#[repr(C)]
7041#[derive(Debug, Copy, Clone)]
7042pub struct spIkConstraint {
7043 pub data: *mut spIkConstraintData,
7044 pub bonesCount: ::std::os::raw::c_int,
7045 pub bones: *mut *mut spBone,
7046 pub target: *mut spBone,
7047 pub bendDirection: ::std::os::raw::c_int,
7048 pub compress: ::std::os::raw::c_int,
7049 pub stretch: ::std::os::raw::c_int,
7050 pub mix: f32,
7051 pub softness: f32,
7052 pub active: ::std::os::raw::c_int,
7053}
7054#[test]
7055fn bindgen_test_layout_spIkConstraint() {
7056 assert_eq!(
7057 ::std::mem::size_of::<spIkConstraint>(),
7058 56usize,
7059 concat!("Size of: ", stringify!(spIkConstraint))
7060 );
7061 assert_eq!(
7062 ::std::mem::align_of::<spIkConstraint>(),
7063 8usize,
7064 concat!("Alignment of ", stringify!(spIkConstraint))
7065 );
7066 assert_eq!(
7067 unsafe { &(*(::std::ptr::null::<spIkConstraint>())).data as *const _ as usize },
7068 0usize,
7069 concat!(
7070 "Offset of field: ",
7071 stringify!(spIkConstraint),
7072 "::",
7073 stringify!(data)
7074 )
7075 );
7076 assert_eq!(
7077 unsafe { &(*(::std::ptr::null::<spIkConstraint>())).bonesCount as *const _ as usize },
7078 8usize,
7079 concat!(
7080 "Offset of field: ",
7081 stringify!(spIkConstraint),
7082 "::",
7083 stringify!(bonesCount)
7084 )
7085 );
7086 assert_eq!(
7087 unsafe { &(*(::std::ptr::null::<spIkConstraint>())).bones as *const _ as usize },
7088 16usize,
7089 concat!(
7090 "Offset of field: ",
7091 stringify!(spIkConstraint),
7092 "::",
7093 stringify!(bones)
7094 )
7095 );
7096 assert_eq!(
7097 unsafe { &(*(::std::ptr::null::<spIkConstraint>())).target as *const _ as usize },
7098 24usize,
7099 concat!(
7100 "Offset of field: ",
7101 stringify!(spIkConstraint),
7102 "::",
7103 stringify!(target)
7104 )
7105 );
7106 assert_eq!(
7107 unsafe { &(*(::std::ptr::null::<spIkConstraint>())).bendDirection as *const _ as usize },
7108 32usize,
7109 concat!(
7110 "Offset of field: ",
7111 stringify!(spIkConstraint),
7112 "::",
7113 stringify!(bendDirection)
7114 )
7115 );
7116 assert_eq!(
7117 unsafe { &(*(::std::ptr::null::<spIkConstraint>())).compress as *const _ as usize },
7118 36usize,
7119 concat!(
7120 "Offset of field: ",
7121 stringify!(spIkConstraint),
7122 "::",
7123 stringify!(compress)
7124 )
7125 );
7126 assert_eq!(
7127 unsafe { &(*(::std::ptr::null::<spIkConstraint>())).stretch as *const _ as usize },
7128 40usize,
7129 concat!(
7130 "Offset of field: ",
7131 stringify!(spIkConstraint),
7132 "::",
7133 stringify!(stretch)
7134 )
7135 );
7136 assert_eq!(
7137 unsafe { &(*(::std::ptr::null::<spIkConstraint>())).mix as *const _ as usize },
7138 44usize,
7139 concat!(
7140 "Offset of field: ",
7141 stringify!(spIkConstraint),
7142 "::",
7143 stringify!(mix)
7144 )
7145 );
7146 assert_eq!(
7147 unsafe { &(*(::std::ptr::null::<spIkConstraint>())).softness as *const _ as usize },
7148 48usize,
7149 concat!(
7150 "Offset of field: ",
7151 stringify!(spIkConstraint),
7152 "::",
7153 stringify!(softness)
7154 )
7155 );
7156 assert_eq!(
7157 unsafe { &(*(::std::ptr::null::<spIkConstraint>())).active as *const _ as usize },
7158 52usize,
7159 concat!(
7160 "Offset of field: ",
7161 stringify!(spIkConstraint),
7162 "::",
7163 stringify!(active)
7164 )
7165 );
7166}
7167extern "C" {
7168 pub fn spIkConstraint_create(
7169 data: *mut spIkConstraintData,
7170 skeleton: *const spSkeleton,
7171 ) -> *mut spIkConstraint;
7172}
7173extern "C" {
7174 pub fn spIkConstraint_dispose(self_: *mut spIkConstraint);
7175}
7176extern "C" {
7177 pub fn spIkConstraint_apply(self_: *mut spIkConstraint);
7178}
7179extern "C" {
7180 pub fn spIkConstraint_apply1(
7181 bone: *mut spBone,
7182 targetX: f32,
7183 targetY: f32,
7184 compress: ::std::os::raw::c_int,
7185 stretch: ::std::os::raw::c_int,
7186 uniform: ::std::os::raw::c_int,
7187 alpha: f32,
7188 );
7189}
7190extern "C" {
7191 pub fn spIkConstraint_apply2(
7192 parent: *mut spBone,
7193 child: *mut spBone,
7194 targetX: f32,
7195 targetY: f32,
7196 bendDirection: ::std::os::raw::c_int,
7197 stretch: ::std::os::raw::c_int,
7198 softness: f32,
7199 alpha: f32,
7200 );
7201}
7202#[repr(C)]
7203#[derive(Debug, Copy, Clone)]
7204pub struct spTransformConstraint {
7205 pub data: *mut spTransformConstraintData,
7206 pub bonesCount: ::std::os::raw::c_int,
7207 pub bones: *mut *mut spBone,
7208 pub target: *mut spBone,
7209 pub rotateMix: f32,
7210 pub translateMix: f32,
7211 pub scaleMix: f32,
7212 pub shearMix: f32,
7213 pub active: ::std::os::raw::c_int,
7214}
7215#[test]
7216fn bindgen_test_layout_spTransformConstraint() {
7217 assert_eq!(
7218 ::std::mem::size_of::<spTransformConstraint>(),
7219 56usize,
7220 concat!("Size of: ", stringify!(spTransformConstraint))
7221 );
7222 assert_eq!(
7223 ::std::mem::align_of::<spTransformConstraint>(),
7224 8usize,
7225 concat!("Alignment of ", stringify!(spTransformConstraint))
7226 );
7227 assert_eq!(
7228 unsafe { &(*(::std::ptr::null::<spTransformConstraint>())).data as *const _ as usize },
7229 0usize,
7230 concat!(
7231 "Offset of field: ",
7232 stringify!(spTransformConstraint),
7233 "::",
7234 stringify!(data)
7235 )
7236 );
7237 assert_eq!(
7238 unsafe {
7239 &(*(::std::ptr::null::<spTransformConstraint>())).bonesCount as *const _ as usize
7240 },
7241 8usize,
7242 concat!(
7243 "Offset of field: ",
7244 stringify!(spTransformConstraint),
7245 "::",
7246 stringify!(bonesCount)
7247 )
7248 );
7249 assert_eq!(
7250 unsafe { &(*(::std::ptr::null::<spTransformConstraint>())).bones as *const _ as usize },
7251 16usize,
7252 concat!(
7253 "Offset of field: ",
7254 stringify!(spTransformConstraint),
7255 "::",
7256 stringify!(bones)
7257 )
7258 );
7259 assert_eq!(
7260 unsafe { &(*(::std::ptr::null::<spTransformConstraint>())).target as *const _ as usize },
7261 24usize,
7262 concat!(
7263 "Offset of field: ",
7264 stringify!(spTransformConstraint),
7265 "::",
7266 stringify!(target)
7267 )
7268 );
7269 assert_eq!(
7270 unsafe { &(*(::std::ptr::null::<spTransformConstraint>())).rotateMix as *const _ as usize },
7271 32usize,
7272 concat!(
7273 "Offset of field: ",
7274 stringify!(spTransformConstraint),
7275 "::",
7276 stringify!(rotateMix)
7277 )
7278 );
7279 assert_eq!(
7280 unsafe {
7281 &(*(::std::ptr::null::<spTransformConstraint>())).translateMix as *const _ as usize
7282 },
7283 36usize,
7284 concat!(
7285 "Offset of field: ",
7286 stringify!(spTransformConstraint),
7287 "::",
7288 stringify!(translateMix)
7289 )
7290 );
7291 assert_eq!(
7292 unsafe { &(*(::std::ptr::null::<spTransformConstraint>())).scaleMix as *const _ as usize },
7293 40usize,
7294 concat!(
7295 "Offset of field: ",
7296 stringify!(spTransformConstraint),
7297 "::",
7298 stringify!(scaleMix)
7299 )
7300 );
7301 assert_eq!(
7302 unsafe { &(*(::std::ptr::null::<spTransformConstraint>())).shearMix as *const _ as usize },
7303 44usize,
7304 concat!(
7305 "Offset of field: ",
7306 stringify!(spTransformConstraint),
7307 "::",
7308 stringify!(shearMix)
7309 )
7310 );
7311 assert_eq!(
7312 unsafe { &(*(::std::ptr::null::<spTransformConstraint>())).active as *const _ as usize },
7313 48usize,
7314 concat!(
7315 "Offset of field: ",
7316 stringify!(spTransformConstraint),
7317 "::",
7318 stringify!(active)
7319 )
7320 );
7321}
7322extern "C" {
7323 pub fn spTransformConstraint_create(
7324 data: *mut spTransformConstraintData,
7325 skeleton: *const spSkeleton,
7326 ) -> *mut spTransformConstraint;
7327}
7328extern "C" {
7329 pub fn spTransformConstraint_dispose(self_: *mut spTransformConstraint);
7330}
7331extern "C" {
7332 pub fn spTransformConstraint_apply(self_: *mut spTransformConstraint);
7333}
7334#[repr(C)]
7335#[derive(Debug, Copy, Clone)]
7336pub struct spPathAttachment {
7337 pub super_: spVertexAttachment,
7338 pub lengthsLength: ::std::os::raw::c_int,
7339 pub lengths: *mut f32,
7340 pub closed: ::std::os::raw::c_int,
7341 pub constantSpeed: ::std::os::raw::c_int,
7342}
7343#[test]
7344fn bindgen_test_layout_spPathAttachment() {
7345 assert_eq!(
7346 ::std::mem::size_of::<spPathAttachment>(),
7347 120usize,
7348 concat!("Size of: ", stringify!(spPathAttachment))
7349 );
7350 assert_eq!(
7351 ::std::mem::align_of::<spPathAttachment>(),
7352 8usize,
7353 concat!("Alignment of ", stringify!(spPathAttachment))
7354 );
7355 assert_eq!(
7356 unsafe { &(*(::std::ptr::null::<spPathAttachment>())).super_ as *const _ as usize },
7357 0usize,
7358 concat!(
7359 "Offset of field: ",
7360 stringify!(spPathAttachment),
7361 "::",
7362 stringify!(super_)
7363 )
7364 );
7365 assert_eq!(
7366 unsafe { &(*(::std::ptr::null::<spPathAttachment>())).lengthsLength as *const _ as usize },
7367 96usize,
7368 concat!(
7369 "Offset of field: ",
7370 stringify!(spPathAttachment),
7371 "::",
7372 stringify!(lengthsLength)
7373 )
7374 );
7375 assert_eq!(
7376 unsafe { &(*(::std::ptr::null::<spPathAttachment>())).lengths as *const _ as usize },
7377 104usize,
7378 concat!(
7379 "Offset of field: ",
7380 stringify!(spPathAttachment),
7381 "::",
7382 stringify!(lengths)
7383 )
7384 );
7385 assert_eq!(
7386 unsafe { &(*(::std::ptr::null::<spPathAttachment>())).closed as *const _ as usize },
7387 112usize,
7388 concat!(
7389 "Offset of field: ",
7390 stringify!(spPathAttachment),
7391 "::",
7392 stringify!(closed)
7393 )
7394 );
7395 assert_eq!(
7396 unsafe { &(*(::std::ptr::null::<spPathAttachment>())).constantSpeed as *const _ as usize },
7397 116usize,
7398 concat!(
7399 "Offset of field: ",
7400 stringify!(spPathAttachment),
7401 "::",
7402 stringify!(constantSpeed)
7403 )
7404 );
7405}
7406extern "C" {
7407 pub fn spPathAttachment_create(name: *const ::std::os::raw::c_char) -> *mut spPathAttachment;
7408}
7409#[repr(C)]
7410#[derive(Debug, Copy, Clone)]
7411pub struct spPathConstraint {
7412 pub data: *mut spPathConstraintData,
7413 pub bonesCount: ::std::os::raw::c_int,
7414 pub bones: *mut *mut spBone,
7415 pub target: *mut spSlot,
7416 pub position: f32,
7417 pub spacing: f32,
7418 pub rotateMix: f32,
7419 pub translateMix: f32,
7420 pub spacesCount: ::std::os::raw::c_int,
7421 pub spaces: *mut f32,
7422 pub positionsCount: ::std::os::raw::c_int,
7423 pub positions: *mut f32,
7424 pub worldCount: ::std::os::raw::c_int,
7425 pub world: *mut f32,
7426 pub curvesCount: ::std::os::raw::c_int,
7427 pub curves: *mut f32,
7428 pub lengthsCount: ::std::os::raw::c_int,
7429 pub lengths: *mut f32,
7430 pub segments: [f32; 10usize],
7431 pub active: ::std::os::raw::c_int,
7432}
7433#[test]
7434fn bindgen_test_layout_spPathConstraint() {
7435 assert_eq!(
7436 ::std::mem::size_of::<spPathConstraint>(),
7437 176usize,
7438 concat!("Size of: ", stringify!(spPathConstraint))
7439 );
7440 assert_eq!(
7441 ::std::mem::align_of::<spPathConstraint>(),
7442 8usize,
7443 concat!("Alignment of ", stringify!(spPathConstraint))
7444 );
7445 assert_eq!(
7446 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).data as *const _ as usize },
7447 0usize,
7448 concat!(
7449 "Offset of field: ",
7450 stringify!(spPathConstraint),
7451 "::",
7452 stringify!(data)
7453 )
7454 );
7455 assert_eq!(
7456 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).bonesCount as *const _ as usize },
7457 8usize,
7458 concat!(
7459 "Offset of field: ",
7460 stringify!(spPathConstraint),
7461 "::",
7462 stringify!(bonesCount)
7463 )
7464 );
7465 assert_eq!(
7466 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).bones as *const _ as usize },
7467 16usize,
7468 concat!(
7469 "Offset of field: ",
7470 stringify!(spPathConstraint),
7471 "::",
7472 stringify!(bones)
7473 )
7474 );
7475 assert_eq!(
7476 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).target as *const _ as usize },
7477 24usize,
7478 concat!(
7479 "Offset of field: ",
7480 stringify!(spPathConstraint),
7481 "::",
7482 stringify!(target)
7483 )
7484 );
7485 assert_eq!(
7486 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).position as *const _ as usize },
7487 32usize,
7488 concat!(
7489 "Offset of field: ",
7490 stringify!(spPathConstraint),
7491 "::",
7492 stringify!(position)
7493 )
7494 );
7495 assert_eq!(
7496 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).spacing as *const _ as usize },
7497 36usize,
7498 concat!(
7499 "Offset of field: ",
7500 stringify!(spPathConstraint),
7501 "::",
7502 stringify!(spacing)
7503 )
7504 );
7505 assert_eq!(
7506 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).rotateMix as *const _ as usize },
7507 40usize,
7508 concat!(
7509 "Offset of field: ",
7510 stringify!(spPathConstraint),
7511 "::",
7512 stringify!(rotateMix)
7513 )
7514 );
7515 assert_eq!(
7516 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).translateMix as *const _ as usize },
7517 44usize,
7518 concat!(
7519 "Offset of field: ",
7520 stringify!(spPathConstraint),
7521 "::",
7522 stringify!(translateMix)
7523 )
7524 );
7525 assert_eq!(
7526 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).spacesCount as *const _ as usize },
7527 48usize,
7528 concat!(
7529 "Offset of field: ",
7530 stringify!(spPathConstraint),
7531 "::",
7532 stringify!(spacesCount)
7533 )
7534 );
7535 assert_eq!(
7536 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).spaces as *const _ as usize },
7537 56usize,
7538 concat!(
7539 "Offset of field: ",
7540 stringify!(spPathConstraint),
7541 "::",
7542 stringify!(spaces)
7543 )
7544 );
7545 assert_eq!(
7546 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).positionsCount as *const _ as usize },
7547 64usize,
7548 concat!(
7549 "Offset of field: ",
7550 stringify!(spPathConstraint),
7551 "::",
7552 stringify!(positionsCount)
7553 )
7554 );
7555 assert_eq!(
7556 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).positions as *const _ as usize },
7557 72usize,
7558 concat!(
7559 "Offset of field: ",
7560 stringify!(spPathConstraint),
7561 "::",
7562 stringify!(positions)
7563 )
7564 );
7565 assert_eq!(
7566 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).worldCount as *const _ as usize },
7567 80usize,
7568 concat!(
7569 "Offset of field: ",
7570 stringify!(spPathConstraint),
7571 "::",
7572 stringify!(worldCount)
7573 )
7574 );
7575 assert_eq!(
7576 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).world as *const _ as usize },
7577 88usize,
7578 concat!(
7579 "Offset of field: ",
7580 stringify!(spPathConstraint),
7581 "::",
7582 stringify!(world)
7583 )
7584 );
7585 assert_eq!(
7586 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).curvesCount as *const _ as usize },
7587 96usize,
7588 concat!(
7589 "Offset of field: ",
7590 stringify!(spPathConstraint),
7591 "::",
7592 stringify!(curvesCount)
7593 )
7594 );
7595 assert_eq!(
7596 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).curves as *const _ as usize },
7597 104usize,
7598 concat!(
7599 "Offset of field: ",
7600 stringify!(spPathConstraint),
7601 "::",
7602 stringify!(curves)
7603 )
7604 );
7605 assert_eq!(
7606 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).lengthsCount as *const _ as usize },
7607 112usize,
7608 concat!(
7609 "Offset of field: ",
7610 stringify!(spPathConstraint),
7611 "::",
7612 stringify!(lengthsCount)
7613 )
7614 );
7615 assert_eq!(
7616 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).lengths as *const _ as usize },
7617 120usize,
7618 concat!(
7619 "Offset of field: ",
7620 stringify!(spPathConstraint),
7621 "::",
7622 stringify!(lengths)
7623 )
7624 );
7625 assert_eq!(
7626 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).segments as *const _ as usize },
7627 128usize,
7628 concat!(
7629 "Offset of field: ",
7630 stringify!(spPathConstraint),
7631 "::",
7632 stringify!(segments)
7633 )
7634 );
7635 assert_eq!(
7636 unsafe { &(*(::std::ptr::null::<spPathConstraint>())).active as *const _ as usize },
7637 168usize,
7638 concat!(
7639 "Offset of field: ",
7640 stringify!(spPathConstraint),
7641 "::",
7642 stringify!(active)
7643 )
7644 );
7645}
7646extern "C" {
7647 pub fn spPathConstraint_create(
7648 data: *mut spPathConstraintData,
7649 skeleton: *const spSkeleton,
7650 ) -> *mut spPathConstraint;
7651}
7652extern "C" {
7653 pub fn spPathConstraint_dispose(self_: *mut spPathConstraint);
7654}
7655extern "C" {
7656 pub fn spPathConstraint_apply(self_: *mut spPathConstraint);
7657}
7658extern "C" {
7659 pub fn spPathConstraint_computeWorldPositions(
7660 self_: *mut spPathConstraint,
7661 path: *mut spPathAttachment,
7662 spacesCount: ::std::os::raw::c_int,
7663 tangents: ::std::os::raw::c_int,
7664 percentPosition: ::std::os::raw::c_int,
7665 percentSpacing: ::std::os::raw::c_int,
7666 ) -> *mut f32;
7667}
7668#[repr(C)]
7669#[derive(Debug, Copy, Clone)]
7670pub struct spSkeleton {
7671 pub data: *mut spSkeletonData,
7672 pub bonesCount: ::std::os::raw::c_int,
7673 pub bones: *mut *mut spBone,
7674 pub root: *mut spBone,
7675 pub slotsCount: ::std::os::raw::c_int,
7676 pub slots: *mut *mut spSlot,
7677 pub drawOrder: *mut *mut spSlot,
7678 pub ikConstraintsCount: ::std::os::raw::c_int,
7679 pub ikConstraints: *mut *mut spIkConstraint,
7680 pub transformConstraintsCount: ::std::os::raw::c_int,
7681 pub transformConstraints: *mut *mut spTransformConstraint,
7682 pub pathConstraintsCount: ::std::os::raw::c_int,
7683 pub pathConstraints: *mut *mut spPathConstraint,
7684 pub skin: *mut spSkin,
7685 pub color: spColor,
7686 pub time: f32,
7687 pub scaleX: f32,
7688 pub scaleY: f32,
7689 pub x: f32,
7690 pub y: f32,
7691}
7692#[test]
7693fn bindgen_test_layout_spSkeleton() {
7694 assert_eq!(
7695 ::std::mem::size_of::<spSkeleton>(),
7696 152usize,
7697 concat!("Size of: ", stringify!(spSkeleton))
7698 );
7699 assert_eq!(
7700 ::std::mem::align_of::<spSkeleton>(),
7701 8usize,
7702 concat!("Alignment of ", stringify!(spSkeleton))
7703 );
7704 assert_eq!(
7705 unsafe { &(*(::std::ptr::null::<spSkeleton>())).data as *const _ as usize },
7706 0usize,
7707 concat!(
7708 "Offset of field: ",
7709 stringify!(spSkeleton),
7710 "::",
7711 stringify!(data)
7712 )
7713 );
7714 assert_eq!(
7715 unsafe { &(*(::std::ptr::null::<spSkeleton>())).bonesCount as *const _ as usize },
7716 8usize,
7717 concat!(
7718 "Offset of field: ",
7719 stringify!(spSkeleton),
7720 "::",
7721 stringify!(bonesCount)
7722 )
7723 );
7724 assert_eq!(
7725 unsafe { &(*(::std::ptr::null::<spSkeleton>())).bones as *const _ as usize },
7726 16usize,
7727 concat!(
7728 "Offset of field: ",
7729 stringify!(spSkeleton),
7730 "::",
7731 stringify!(bones)
7732 )
7733 );
7734 assert_eq!(
7735 unsafe { &(*(::std::ptr::null::<spSkeleton>())).root as *const _ as usize },
7736 24usize,
7737 concat!(
7738 "Offset of field: ",
7739 stringify!(spSkeleton),
7740 "::",
7741 stringify!(root)
7742 )
7743 );
7744 assert_eq!(
7745 unsafe { &(*(::std::ptr::null::<spSkeleton>())).slotsCount as *const _ as usize },
7746 32usize,
7747 concat!(
7748 "Offset of field: ",
7749 stringify!(spSkeleton),
7750 "::",
7751 stringify!(slotsCount)
7752 )
7753 );
7754 assert_eq!(
7755 unsafe { &(*(::std::ptr::null::<spSkeleton>())).slots as *const _ as usize },
7756 40usize,
7757 concat!(
7758 "Offset of field: ",
7759 stringify!(spSkeleton),
7760 "::",
7761 stringify!(slots)
7762 )
7763 );
7764 assert_eq!(
7765 unsafe { &(*(::std::ptr::null::<spSkeleton>())).drawOrder as *const _ as usize },
7766 48usize,
7767 concat!(
7768 "Offset of field: ",
7769 stringify!(spSkeleton),
7770 "::",
7771 stringify!(drawOrder)
7772 )
7773 );
7774 assert_eq!(
7775 unsafe { &(*(::std::ptr::null::<spSkeleton>())).ikConstraintsCount as *const _ as usize },
7776 56usize,
7777 concat!(
7778 "Offset of field: ",
7779 stringify!(spSkeleton),
7780 "::",
7781 stringify!(ikConstraintsCount)
7782 )
7783 );
7784 assert_eq!(
7785 unsafe { &(*(::std::ptr::null::<spSkeleton>())).ikConstraints as *const _ as usize },
7786 64usize,
7787 concat!(
7788 "Offset of field: ",
7789 stringify!(spSkeleton),
7790 "::",
7791 stringify!(ikConstraints)
7792 )
7793 );
7794 assert_eq!(
7795 unsafe {
7796 &(*(::std::ptr::null::<spSkeleton>())).transformConstraintsCount as *const _ as usize
7797 },
7798 72usize,
7799 concat!(
7800 "Offset of field: ",
7801 stringify!(spSkeleton),
7802 "::",
7803 stringify!(transformConstraintsCount)
7804 )
7805 );
7806 assert_eq!(
7807 unsafe { &(*(::std::ptr::null::<spSkeleton>())).transformConstraints as *const _ as usize },
7808 80usize,
7809 concat!(
7810 "Offset of field: ",
7811 stringify!(spSkeleton),
7812 "::",
7813 stringify!(transformConstraints)
7814 )
7815 );
7816 assert_eq!(
7817 unsafe { &(*(::std::ptr::null::<spSkeleton>())).pathConstraintsCount as *const _ as usize },
7818 88usize,
7819 concat!(
7820 "Offset of field: ",
7821 stringify!(spSkeleton),
7822 "::",
7823 stringify!(pathConstraintsCount)
7824 )
7825 );
7826 assert_eq!(
7827 unsafe { &(*(::std::ptr::null::<spSkeleton>())).pathConstraints as *const _ as usize },
7828 96usize,
7829 concat!(
7830 "Offset of field: ",
7831 stringify!(spSkeleton),
7832 "::",
7833 stringify!(pathConstraints)
7834 )
7835 );
7836 assert_eq!(
7837 unsafe { &(*(::std::ptr::null::<spSkeleton>())).skin as *const _ as usize },
7838 104usize,
7839 concat!(
7840 "Offset of field: ",
7841 stringify!(spSkeleton),
7842 "::",
7843 stringify!(skin)
7844 )
7845 );
7846 assert_eq!(
7847 unsafe { &(*(::std::ptr::null::<spSkeleton>())).color as *const _ as usize },
7848 112usize,
7849 concat!(
7850 "Offset of field: ",
7851 stringify!(spSkeleton),
7852 "::",
7853 stringify!(color)
7854 )
7855 );
7856 assert_eq!(
7857 unsafe { &(*(::std::ptr::null::<spSkeleton>())).time as *const _ as usize },
7858 128usize,
7859 concat!(
7860 "Offset of field: ",
7861 stringify!(spSkeleton),
7862 "::",
7863 stringify!(time)
7864 )
7865 );
7866 assert_eq!(
7867 unsafe { &(*(::std::ptr::null::<spSkeleton>())).scaleX as *const _ as usize },
7868 132usize,
7869 concat!(
7870 "Offset of field: ",
7871 stringify!(spSkeleton),
7872 "::",
7873 stringify!(scaleX)
7874 )
7875 );
7876 assert_eq!(
7877 unsafe { &(*(::std::ptr::null::<spSkeleton>())).scaleY as *const _ as usize },
7878 136usize,
7879 concat!(
7880 "Offset of field: ",
7881 stringify!(spSkeleton),
7882 "::",
7883 stringify!(scaleY)
7884 )
7885 );
7886 assert_eq!(
7887 unsafe { &(*(::std::ptr::null::<spSkeleton>())).x as *const _ as usize },
7888 140usize,
7889 concat!(
7890 "Offset of field: ",
7891 stringify!(spSkeleton),
7892 "::",
7893 stringify!(x)
7894 )
7895 );
7896 assert_eq!(
7897 unsafe { &(*(::std::ptr::null::<spSkeleton>())).y as *const _ as usize },
7898 144usize,
7899 concat!(
7900 "Offset of field: ",
7901 stringify!(spSkeleton),
7902 "::",
7903 stringify!(y)
7904 )
7905 );
7906}
7907extern "C" {
7908 pub fn spSkeleton_create(data: *mut spSkeletonData) -> *mut spSkeleton;
7909}
7910extern "C" {
7911 pub fn spSkeleton_dispose(self_: *mut spSkeleton);
7912}
7913extern "C" {
7914 pub fn spSkeleton_updateCache(self_: *mut spSkeleton);
7915}
7916extern "C" {
7917 pub fn spSkeleton_updateWorldTransform(self_: *const spSkeleton);
7918}
7919extern "C" {
7920 pub fn spSkeleton_setToSetupPose(self_: *const spSkeleton);
7921}
7922extern "C" {
7923 pub fn spSkeleton_setBonesToSetupPose(self_: *const spSkeleton);
7924}
7925extern "C" {
7926 pub fn spSkeleton_setSlotsToSetupPose(self_: *const spSkeleton);
7927}
7928extern "C" {
7929 pub fn spSkeleton_findBone(
7930 self_: *const spSkeleton,
7931 boneName: *const ::std::os::raw::c_char,
7932 ) -> *mut spBone;
7933}
7934extern "C" {
7935 pub fn spSkeleton_findBoneIndex(
7936 self_: *const spSkeleton,
7937 boneName: *const ::std::os::raw::c_char,
7938 ) -> ::std::os::raw::c_int;
7939}
7940extern "C" {
7941 pub fn spSkeleton_findSlot(
7942 self_: *const spSkeleton,
7943 slotName: *const ::std::os::raw::c_char,
7944 ) -> *mut spSlot;
7945}
7946extern "C" {
7947 pub fn spSkeleton_findSlotIndex(
7948 self_: *const spSkeleton,
7949 slotName: *const ::std::os::raw::c_char,
7950 ) -> ::std::os::raw::c_int;
7951}
7952extern "C" {
7953 pub fn spSkeleton_setSkin(self_: *mut spSkeleton, skin: *mut spSkin);
7954}
7955extern "C" {
7956 pub fn spSkeleton_setSkinByName(
7957 self_: *mut spSkeleton,
7958 skinName: *const ::std::os::raw::c_char,
7959 ) -> ::std::os::raw::c_int;
7960}
7961extern "C" {
7962 pub fn spSkeleton_getAttachmentForSlotName(
7963 self_: *const spSkeleton,
7964 slotName: *const ::std::os::raw::c_char,
7965 attachmentName: *const ::std::os::raw::c_char,
7966 ) -> *mut spAttachment;
7967}
7968extern "C" {
7969 pub fn spSkeleton_getAttachmentForSlotIndex(
7970 self_: *const spSkeleton,
7971 slotIndex: ::std::os::raw::c_int,
7972 attachmentName: *const ::std::os::raw::c_char,
7973 ) -> *mut spAttachment;
7974}
7975extern "C" {
7976 pub fn spSkeleton_setAttachment(
7977 self_: *mut spSkeleton,
7978 slotName: *const ::std::os::raw::c_char,
7979 attachmentName: *const ::std::os::raw::c_char,
7980 ) -> ::std::os::raw::c_int;
7981}
7982extern "C" {
7983 pub fn spSkeleton_findIkConstraint(
7984 self_: *const spSkeleton,
7985 constraintName: *const ::std::os::raw::c_char,
7986 ) -> *mut spIkConstraint;
7987}
7988extern "C" {
7989 pub fn spSkeleton_findTransformConstraint(
7990 self_: *const spSkeleton,
7991 constraintName: *const ::std::os::raw::c_char,
7992 ) -> *mut spTransformConstraint;
7993}
7994extern "C" {
7995 pub fn spSkeleton_findPathConstraint(
7996 self_: *const spSkeleton,
7997 constraintName: *const ::std::os::raw::c_char,
7998 ) -> *mut spPathConstraint;
7999}
8000extern "C" {
8001 pub fn spSkeleton_update(self_: *mut spSkeleton, deltaTime: f32);
8002}
8003#[repr(C)]
8004#[derive(Debug, Copy, Clone)]
8005pub struct spPolygon {
8006 pub vertices: *mut f32,
8007 pub count: ::std::os::raw::c_int,
8008 pub capacity: ::std::os::raw::c_int,
8009}
8010#[test]
8011fn bindgen_test_layout_spPolygon() {
8012 assert_eq!(
8013 ::std::mem::size_of::<spPolygon>(),
8014 16usize,
8015 concat!("Size of: ", stringify!(spPolygon))
8016 );
8017 assert_eq!(
8018 ::std::mem::align_of::<spPolygon>(),
8019 8usize,
8020 concat!("Alignment of ", stringify!(spPolygon))
8021 );
8022 assert_eq!(
8023 unsafe { &(*(::std::ptr::null::<spPolygon>())).vertices as *const _ as usize },
8024 0usize,
8025 concat!(
8026 "Offset of field: ",
8027 stringify!(spPolygon),
8028 "::",
8029 stringify!(vertices)
8030 )
8031 );
8032 assert_eq!(
8033 unsafe { &(*(::std::ptr::null::<spPolygon>())).count as *const _ as usize },
8034 8usize,
8035 concat!(
8036 "Offset of field: ",
8037 stringify!(spPolygon),
8038 "::",
8039 stringify!(count)
8040 )
8041 );
8042 assert_eq!(
8043 unsafe { &(*(::std::ptr::null::<spPolygon>())).capacity as *const _ as usize },
8044 12usize,
8045 concat!(
8046 "Offset of field: ",
8047 stringify!(spPolygon),
8048 "::",
8049 stringify!(capacity)
8050 )
8051 );
8052}
8053extern "C" {
8054 pub fn spPolygon_create(capacity: ::std::os::raw::c_int) -> *mut spPolygon;
8055}
8056extern "C" {
8057 pub fn spPolygon_dispose(self_: *mut spPolygon);
8058}
8059extern "C" {
8060 pub fn spPolygon_containsPoint(
8061 polygon: *mut spPolygon,
8062 x: f32,
8063 y: f32,
8064 ) -> ::std::os::raw::c_int;
8065}
8066extern "C" {
8067 pub fn spPolygon_intersectsSegment(
8068 polygon: *mut spPolygon,
8069 x1: f32,
8070 y1: f32,
8071 x2: f32,
8072 y2: f32,
8073 ) -> ::std::os::raw::c_int;
8074}
8075#[repr(C)]
8076#[derive(Debug, Copy, Clone)]
8077pub struct spSkeletonBounds {
8078 pub count: ::std::os::raw::c_int,
8079 pub boundingBoxes: *mut *mut spBoundingBoxAttachment,
8080 pub polygons: *mut *mut spPolygon,
8081 pub minX: f32,
8082 pub minY: f32,
8083 pub maxX: f32,
8084 pub maxY: f32,
8085}
8086#[test]
8087fn bindgen_test_layout_spSkeletonBounds() {
8088 assert_eq!(
8089 ::std::mem::size_of::<spSkeletonBounds>(),
8090 40usize,
8091 concat!("Size of: ", stringify!(spSkeletonBounds))
8092 );
8093 assert_eq!(
8094 ::std::mem::align_of::<spSkeletonBounds>(),
8095 8usize,
8096 concat!("Alignment of ", stringify!(spSkeletonBounds))
8097 );
8098 assert_eq!(
8099 unsafe { &(*(::std::ptr::null::<spSkeletonBounds>())).count as *const _ as usize },
8100 0usize,
8101 concat!(
8102 "Offset of field: ",
8103 stringify!(spSkeletonBounds),
8104 "::",
8105 stringify!(count)
8106 )
8107 );
8108 assert_eq!(
8109 unsafe { &(*(::std::ptr::null::<spSkeletonBounds>())).boundingBoxes as *const _ as usize },
8110 8usize,
8111 concat!(
8112 "Offset of field: ",
8113 stringify!(spSkeletonBounds),
8114 "::",
8115 stringify!(boundingBoxes)
8116 )
8117 );
8118 assert_eq!(
8119 unsafe { &(*(::std::ptr::null::<spSkeletonBounds>())).polygons as *const _ as usize },
8120 16usize,
8121 concat!(
8122 "Offset of field: ",
8123 stringify!(spSkeletonBounds),
8124 "::",
8125 stringify!(polygons)
8126 )
8127 );
8128 assert_eq!(
8129 unsafe { &(*(::std::ptr::null::<spSkeletonBounds>())).minX as *const _ as usize },
8130 24usize,
8131 concat!(
8132 "Offset of field: ",
8133 stringify!(spSkeletonBounds),
8134 "::",
8135 stringify!(minX)
8136 )
8137 );
8138 assert_eq!(
8139 unsafe { &(*(::std::ptr::null::<spSkeletonBounds>())).minY as *const _ as usize },
8140 28usize,
8141 concat!(
8142 "Offset of field: ",
8143 stringify!(spSkeletonBounds),
8144 "::",
8145 stringify!(minY)
8146 )
8147 );
8148 assert_eq!(
8149 unsafe { &(*(::std::ptr::null::<spSkeletonBounds>())).maxX as *const _ as usize },
8150 32usize,
8151 concat!(
8152 "Offset of field: ",
8153 stringify!(spSkeletonBounds),
8154 "::",
8155 stringify!(maxX)
8156 )
8157 );
8158 assert_eq!(
8159 unsafe { &(*(::std::ptr::null::<spSkeletonBounds>())).maxY as *const _ as usize },
8160 36usize,
8161 concat!(
8162 "Offset of field: ",
8163 stringify!(spSkeletonBounds),
8164 "::",
8165 stringify!(maxY)
8166 )
8167 );
8168}
8169extern "C" {
8170 pub fn spSkeletonBounds_create() -> *mut spSkeletonBounds;
8171}
8172extern "C" {
8173 pub fn spSkeletonBounds_dispose(self_: *mut spSkeletonBounds);
8174}
8175extern "C" {
8176 pub fn spSkeletonBounds_update(
8177 self_: *mut spSkeletonBounds,
8178 skeleton: *mut spSkeleton,
8179 updateAabb: ::std::os::raw::c_int,
8180 );
8181}
8182extern "C" {
8183 #[doc = " Returns true if the axis aligned bounding box contains the point."]
8184 pub fn spSkeletonBounds_aabbContainsPoint(
8185 self_: *mut spSkeletonBounds,
8186 x: f32,
8187 y: f32,
8188 ) -> ::std::os::raw::c_int;
8189}
8190extern "C" {
8191 #[doc = " Returns true if the axis aligned bounding box intersects the line segment."]
8192 pub fn spSkeletonBounds_aabbIntersectsSegment(
8193 self_: *mut spSkeletonBounds,
8194 x1: f32,
8195 y1: f32,
8196 x2: f32,
8197 y2: f32,
8198 ) -> ::std::os::raw::c_int;
8199}
8200extern "C" {
8201 #[doc = " Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds."]
8202 pub fn spSkeletonBounds_aabbIntersectsSkeleton(
8203 self_: *mut spSkeletonBounds,
8204 bounds: *mut spSkeletonBounds,
8205 ) -> ::std::os::raw::c_int;
8206}
8207extern "C" {
8208 #[doc = " Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more"]
8209 #[doc = " efficient to only call this method if spSkeletonBounds_aabbContainsPoint returns true."]
8210 pub fn spSkeletonBounds_containsPoint(
8211 self_: *mut spSkeletonBounds,
8212 x: f32,
8213 y: f32,
8214 ) -> *mut spBoundingBoxAttachment;
8215}
8216extern "C" {
8217 #[doc = " Returns the first bounding box attachment that contains the line segment, or null. When doing many checks, it is usually"]
8218 #[doc = " more efficient to only call this method if spSkeletonBounds_aabbIntersectsSegment returns true."]
8219 pub fn spSkeletonBounds_intersectsSegment(
8220 self_: *mut spSkeletonBounds,
8221 x1: f32,
8222 y1: f32,
8223 x2: f32,
8224 y2: f32,
8225 ) -> *mut spBoundingBoxAttachment;
8226}
8227extern "C" {
8228 #[doc = " Returns the polygon for the specified bounding box, or null."]
8229 pub fn spSkeletonBounds_getPolygon(
8230 self_: *mut spSkeletonBounds,
8231 boundingBox: *mut spBoundingBoxAttachment,
8232 ) -> *mut spPolygon;
8233}
8234#[repr(C)]
8235#[derive(Debug, Copy, Clone)]
8236pub struct spSkeletonBinary {
8237 pub scale: f32,
8238 pub attachmentLoader: *mut spAttachmentLoader,
8239 pub error: *const ::std::os::raw::c_char,
8240}
8241#[test]
8242fn bindgen_test_layout_spSkeletonBinary() {
8243 assert_eq!(
8244 ::std::mem::size_of::<spSkeletonBinary>(),
8245 24usize,
8246 concat!("Size of: ", stringify!(spSkeletonBinary))
8247 );
8248 assert_eq!(
8249 ::std::mem::align_of::<spSkeletonBinary>(),
8250 8usize,
8251 concat!("Alignment of ", stringify!(spSkeletonBinary))
8252 );
8253 assert_eq!(
8254 unsafe { &(*(::std::ptr::null::<spSkeletonBinary>())).scale as *const _ as usize },
8255 0usize,
8256 concat!(
8257 "Offset of field: ",
8258 stringify!(spSkeletonBinary),
8259 "::",
8260 stringify!(scale)
8261 )
8262 );
8263 assert_eq!(
8264 unsafe {
8265 &(*(::std::ptr::null::<spSkeletonBinary>())).attachmentLoader as *const _ as usize
8266 },
8267 8usize,
8268 concat!(
8269 "Offset of field: ",
8270 stringify!(spSkeletonBinary),
8271 "::",
8272 stringify!(attachmentLoader)
8273 )
8274 );
8275 assert_eq!(
8276 unsafe { &(*(::std::ptr::null::<spSkeletonBinary>())).error as *const _ as usize },
8277 16usize,
8278 concat!(
8279 "Offset of field: ",
8280 stringify!(spSkeletonBinary),
8281 "::",
8282 stringify!(error)
8283 )
8284 );
8285}
8286extern "C" {
8287 pub fn spSkeletonBinary_createWithLoader(
8288 attachmentLoader: *mut spAttachmentLoader,
8289 ) -> *mut spSkeletonBinary;
8290}
8291extern "C" {
8292 pub fn spSkeletonBinary_create(atlas: *mut spAtlas) -> *mut spSkeletonBinary;
8293}
8294extern "C" {
8295 pub fn spSkeletonBinary_dispose(self_: *mut spSkeletonBinary);
8296}
8297extern "C" {
8298 pub fn spSkeletonBinary_readSkeletonData(
8299 self_: *mut spSkeletonBinary,
8300 binary: *const ::std::os::raw::c_uchar,
8301 length: ::std::os::raw::c_int,
8302 ) -> *mut spSkeletonData;
8303}
8304extern "C" {
8305 pub fn spSkeletonBinary_readSkeletonDataFile(
8306 self_: *mut spSkeletonBinary,
8307 path: *const ::std::os::raw::c_char,
8308 ) -> *mut spSkeletonData;
8309}
8310#[repr(C)]
8311#[derive(Debug, Copy, Clone)]
8312pub struct spSkeletonJson {
8313 pub scale: f32,
8314 pub attachmentLoader: *mut spAttachmentLoader,
8315 pub error: *const ::std::os::raw::c_char,
8316}
8317#[test]
8318fn bindgen_test_layout_spSkeletonJson() {
8319 assert_eq!(
8320 ::std::mem::size_of::<spSkeletonJson>(),
8321 24usize,
8322 concat!("Size of: ", stringify!(spSkeletonJson))
8323 );
8324 assert_eq!(
8325 ::std::mem::align_of::<spSkeletonJson>(),
8326 8usize,
8327 concat!("Alignment of ", stringify!(spSkeletonJson))
8328 );
8329 assert_eq!(
8330 unsafe { &(*(::std::ptr::null::<spSkeletonJson>())).scale as *const _ as usize },
8331 0usize,
8332 concat!(
8333 "Offset of field: ",
8334 stringify!(spSkeletonJson),
8335 "::",
8336 stringify!(scale)
8337 )
8338 );
8339 assert_eq!(
8340 unsafe { &(*(::std::ptr::null::<spSkeletonJson>())).attachmentLoader as *const _ as usize },
8341 8usize,
8342 concat!(
8343 "Offset of field: ",
8344 stringify!(spSkeletonJson),
8345 "::",
8346 stringify!(attachmentLoader)
8347 )
8348 );
8349 assert_eq!(
8350 unsafe { &(*(::std::ptr::null::<spSkeletonJson>())).error as *const _ as usize },
8351 16usize,
8352 concat!(
8353 "Offset of field: ",
8354 stringify!(spSkeletonJson),
8355 "::",
8356 stringify!(error)
8357 )
8358 );
8359}
8360extern "C" {
8361 pub fn spSkeletonJson_createWithLoader(
8362 attachmentLoader: *mut spAttachmentLoader,
8363 ) -> *mut spSkeletonJson;
8364}
8365extern "C" {
8366 pub fn spSkeletonJson_create(atlas: *mut spAtlas) -> *mut spSkeletonJson;
8367}
8368extern "C" {
8369 pub fn spSkeletonJson_dispose(self_: *mut spSkeletonJson);
8370}
8371extern "C" {
8372 pub fn spSkeletonJson_readSkeletonData(
8373 self_: *mut spSkeletonJson,
8374 json: *const ::std::os::raw::c_char,
8375 ) -> *mut spSkeletonData;
8376}
8377extern "C" {
8378 pub fn spSkeletonJson_readSkeletonDataFile(
8379 self_: *mut spSkeletonJson,
8380 path: *const ::std::os::raw::c_char,
8381 ) -> *mut spSkeletonData;
8382}
8383#[repr(C)]
8384#[derive(Debug, Copy, Clone)]
8385pub struct spTriangulator {
8386 pub convexPolygons: *mut spArrayFloatArray,
8387 pub convexPolygonsIndices: *mut spArrayShortArray,
8388 pub indicesArray: *mut spShortArray,
8389 pub isConcaveArray: *mut spIntArray,
8390 pub triangles: *mut spShortArray,
8391 pub polygonPool: *mut spArrayFloatArray,
8392 pub polygonIndicesPool: *mut spArrayShortArray,
8393}
8394#[test]
8395fn bindgen_test_layout_spTriangulator() {
8396 assert_eq!(
8397 ::std::mem::size_of::<spTriangulator>(),
8398 56usize,
8399 concat!("Size of: ", stringify!(spTriangulator))
8400 );
8401 assert_eq!(
8402 ::std::mem::align_of::<spTriangulator>(),
8403 8usize,
8404 concat!("Alignment of ", stringify!(spTriangulator))
8405 );
8406 assert_eq!(
8407 unsafe { &(*(::std::ptr::null::<spTriangulator>())).convexPolygons as *const _ as usize },
8408 0usize,
8409 concat!(
8410 "Offset of field: ",
8411 stringify!(spTriangulator),
8412 "::",
8413 stringify!(convexPolygons)
8414 )
8415 );
8416 assert_eq!(
8417 unsafe {
8418 &(*(::std::ptr::null::<spTriangulator>())).convexPolygonsIndices as *const _ as usize
8419 },
8420 8usize,
8421 concat!(
8422 "Offset of field: ",
8423 stringify!(spTriangulator),
8424 "::",
8425 stringify!(convexPolygonsIndices)
8426 )
8427 );
8428 assert_eq!(
8429 unsafe { &(*(::std::ptr::null::<spTriangulator>())).indicesArray as *const _ as usize },
8430 16usize,
8431 concat!(
8432 "Offset of field: ",
8433 stringify!(spTriangulator),
8434 "::",
8435 stringify!(indicesArray)
8436 )
8437 );
8438 assert_eq!(
8439 unsafe { &(*(::std::ptr::null::<spTriangulator>())).isConcaveArray as *const _ as usize },
8440 24usize,
8441 concat!(
8442 "Offset of field: ",
8443 stringify!(spTriangulator),
8444 "::",
8445 stringify!(isConcaveArray)
8446 )
8447 );
8448 assert_eq!(
8449 unsafe { &(*(::std::ptr::null::<spTriangulator>())).triangles as *const _ as usize },
8450 32usize,
8451 concat!(
8452 "Offset of field: ",
8453 stringify!(spTriangulator),
8454 "::",
8455 stringify!(triangles)
8456 )
8457 );
8458 assert_eq!(
8459 unsafe { &(*(::std::ptr::null::<spTriangulator>())).polygonPool as *const _ as usize },
8460 40usize,
8461 concat!(
8462 "Offset of field: ",
8463 stringify!(spTriangulator),
8464 "::",
8465 stringify!(polygonPool)
8466 )
8467 );
8468 assert_eq!(
8469 unsafe {
8470 &(*(::std::ptr::null::<spTriangulator>())).polygonIndicesPool as *const _ as usize
8471 },
8472 48usize,
8473 concat!(
8474 "Offset of field: ",
8475 stringify!(spTriangulator),
8476 "::",
8477 stringify!(polygonIndicesPool)
8478 )
8479 );
8480}
8481extern "C" {
8482 pub fn spTriangulator_create() -> *mut spTriangulator;
8483}
8484extern "C" {
8485 pub fn spTriangulator_triangulate(
8486 self_: *mut spTriangulator,
8487 verticesArray: *mut spFloatArray,
8488 ) -> *mut spShortArray;
8489}
8490extern "C" {
8491 pub fn spTriangulator_decompose(
8492 self_: *mut spTriangulator,
8493 verticesArray: *mut spFloatArray,
8494 triangles: *mut spShortArray,
8495 ) -> *mut spArrayFloatArray;
8496}
8497extern "C" {
8498 pub fn spTriangulator_dispose(self_: *mut spTriangulator);
8499}
8500#[repr(C)]
8501#[derive(Debug, Copy, Clone)]
8502pub struct spSkeletonClipping {
8503 pub triangulator: *mut spTriangulator,
8504 pub clippingPolygon: *mut spFloatArray,
8505 pub clipOutput: *mut spFloatArray,
8506 pub clippedVertices: *mut spFloatArray,
8507 pub clippedUVs: *mut spFloatArray,
8508 pub clippedTriangles: *mut spUnsignedShortArray,
8509 pub scratch: *mut spFloatArray,
8510 pub clipAttachment: *mut spClippingAttachment,
8511 pub clippingPolygons: *mut spArrayFloatArray,
8512}
8513#[test]
8514fn bindgen_test_layout_spSkeletonClipping() {
8515 assert_eq!(
8516 ::std::mem::size_of::<spSkeletonClipping>(),
8517 72usize,
8518 concat!("Size of: ", stringify!(spSkeletonClipping))
8519 );
8520 assert_eq!(
8521 ::std::mem::align_of::<spSkeletonClipping>(),
8522 8usize,
8523 concat!("Alignment of ", stringify!(spSkeletonClipping))
8524 );
8525 assert_eq!(
8526 unsafe { &(*(::std::ptr::null::<spSkeletonClipping>())).triangulator as *const _ as usize },
8527 0usize,
8528 concat!(
8529 "Offset of field: ",
8530 stringify!(spSkeletonClipping),
8531 "::",
8532 stringify!(triangulator)
8533 )
8534 );
8535 assert_eq!(
8536 unsafe {
8537 &(*(::std::ptr::null::<spSkeletonClipping>())).clippingPolygon as *const _ as usize
8538 },
8539 8usize,
8540 concat!(
8541 "Offset of field: ",
8542 stringify!(spSkeletonClipping),
8543 "::",
8544 stringify!(clippingPolygon)
8545 )
8546 );
8547 assert_eq!(
8548 unsafe { &(*(::std::ptr::null::<spSkeletonClipping>())).clipOutput as *const _ as usize },
8549 16usize,
8550 concat!(
8551 "Offset of field: ",
8552 stringify!(spSkeletonClipping),
8553 "::",
8554 stringify!(clipOutput)
8555 )
8556 );
8557 assert_eq!(
8558 unsafe {
8559 &(*(::std::ptr::null::<spSkeletonClipping>())).clippedVertices as *const _ as usize
8560 },
8561 24usize,
8562 concat!(
8563 "Offset of field: ",
8564 stringify!(spSkeletonClipping),
8565 "::",
8566 stringify!(clippedVertices)
8567 )
8568 );
8569 assert_eq!(
8570 unsafe { &(*(::std::ptr::null::<spSkeletonClipping>())).clippedUVs as *const _ as usize },
8571 32usize,
8572 concat!(
8573 "Offset of field: ",
8574 stringify!(spSkeletonClipping),
8575 "::",
8576 stringify!(clippedUVs)
8577 )
8578 );
8579 assert_eq!(
8580 unsafe {
8581 &(*(::std::ptr::null::<spSkeletonClipping>())).clippedTriangles as *const _ as usize
8582 },
8583 40usize,
8584 concat!(
8585 "Offset of field: ",
8586 stringify!(spSkeletonClipping),
8587 "::",
8588 stringify!(clippedTriangles)
8589 )
8590 );
8591 assert_eq!(
8592 unsafe { &(*(::std::ptr::null::<spSkeletonClipping>())).scratch as *const _ as usize },
8593 48usize,
8594 concat!(
8595 "Offset of field: ",
8596 stringify!(spSkeletonClipping),
8597 "::",
8598 stringify!(scratch)
8599 )
8600 );
8601 assert_eq!(
8602 unsafe {
8603 &(*(::std::ptr::null::<spSkeletonClipping>())).clipAttachment as *const _ as usize
8604 },
8605 56usize,
8606 concat!(
8607 "Offset of field: ",
8608 stringify!(spSkeletonClipping),
8609 "::",
8610 stringify!(clipAttachment)
8611 )
8612 );
8613 assert_eq!(
8614 unsafe {
8615 &(*(::std::ptr::null::<spSkeletonClipping>())).clippingPolygons as *const _ as usize
8616 },
8617 64usize,
8618 concat!(
8619 "Offset of field: ",
8620 stringify!(spSkeletonClipping),
8621 "::",
8622 stringify!(clippingPolygons)
8623 )
8624 );
8625}
8626extern "C" {
8627 pub fn spSkeletonClipping_create() -> *mut spSkeletonClipping;
8628}
8629extern "C" {
8630 pub fn spSkeletonClipping_clipStart(
8631 self_: *mut spSkeletonClipping,
8632 slot: *mut spSlot,
8633 clip: *mut spClippingAttachment,
8634 ) -> ::std::os::raw::c_int;
8635}
8636extern "C" {
8637 pub fn spSkeletonClipping_clipEnd(self_: *mut spSkeletonClipping, slot: *mut spSlot);
8638}
8639extern "C" {
8640 pub fn spSkeletonClipping_clipEnd2(self_: *mut spSkeletonClipping);
8641}
8642extern "C" {
8643 pub fn spSkeletonClipping_isClipping(self_: *mut spSkeletonClipping) -> ::std::os::raw::c_int;
8644}
8645extern "C" {
8646 pub fn spSkeletonClipping_clipTriangles(
8647 self_: *mut spSkeletonClipping,
8648 vertices: *mut f32,
8649 verticesLength: ::std::os::raw::c_int,
8650 triangles: *mut ::std::os::raw::c_ushort,
8651 trianglesLength: ::std::os::raw::c_int,
8652 uvs: *mut f32,
8653 stride: ::std::os::raw::c_int,
8654 );
8655}
8656extern "C" {
8657 pub fn spSkeletonClipping_dispose(self_: *mut spSkeletonClipping);
8658}
8659pub type spVertexEffectBegin = ::std::option::Option<
8660 unsafe extern "C" fn(self_: *mut spVertexEffect, skeleton: *mut spSkeleton),
8661>;
8662pub type spVertexEffectTransform = ::std::option::Option<
8663 unsafe extern "C" fn(
8664 self_: *mut spVertexEffect,
8665 x: *mut f32,
8666 y: *mut f32,
8667 u: *mut f32,
8668 v: *mut f32,
8669 light: *mut spColor,
8670 dark: *mut spColor,
8671 ),
8672>;
8673pub type spVertexEffectEnd =
8674 ::std::option::Option<unsafe extern "C" fn(self_: *mut spVertexEffect)>;
8675#[repr(C)]
8676#[derive(Debug, Copy, Clone)]
8677pub struct spVertexEffect {
8678 pub begin: spVertexEffectBegin,
8679 pub transform: spVertexEffectTransform,
8680 pub end: spVertexEffectEnd,
8681}
8682#[test]
8683fn bindgen_test_layout_spVertexEffect() {
8684 assert_eq!(
8685 ::std::mem::size_of::<spVertexEffect>(),
8686 24usize,
8687 concat!("Size of: ", stringify!(spVertexEffect))
8688 );
8689 assert_eq!(
8690 ::std::mem::align_of::<spVertexEffect>(),
8691 8usize,
8692 concat!("Alignment of ", stringify!(spVertexEffect))
8693 );
8694 assert_eq!(
8695 unsafe { &(*(::std::ptr::null::<spVertexEffect>())).begin as *const _ as usize },
8696 0usize,
8697 concat!(
8698 "Offset of field: ",
8699 stringify!(spVertexEffect),
8700 "::",
8701 stringify!(begin)
8702 )
8703 );
8704 assert_eq!(
8705 unsafe { &(*(::std::ptr::null::<spVertexEffect>())).transform as *const _ as usize },
8706 8usize,
8707 concat!(
8708 "Offset of field: ",
8709 stringify!(spVertexEffect),
8710 "::",
8711 stringify!(transform)
8712 )
8713 );
8714 assert_eq!(
8715 unsafe { &(*(::std::ptr::null::<spVertexEffect>())).end as *const _ as usize },
8716 16usize,
8717 concat!(
8718 "Offset of field: ",
8719 stringify!(spVertexEffect),
8720 "::",
8721 stringify!(end)
8722 )
8723 );
8724}
8725#[repr(C)]
8726#[derive(Debug, Copy, Clone)]
8727pub struct spJitterVertexEffect {
8728 pub super_: spVertexEffect,
8729 pub jitterX: f32,
8730 pub jitterY: f32,
8731}
8732#[test]
8733fn bindgen_test_layout_spJitterVertexEffect() {
8734 assert_eq!(
8735 ::std::mem::size_of::<spJitterVertexEffect>(),
8736 32usize,
8737 concat!("Size of: ", stringify!(spJitterVertexEffect))
8738 );
8739 assert_eq!(
8740 ::std::mem::align_of::<spJitterVertexEffect>(),
8741 8usize,
8742 concat!("Alignment of ", stringify!(spJitterVertexEffect))
8743 );
8744 assert_eq!(
8745 unsafe { &(*(::std::ptr::null::<spJitterVertexEffect>())).super_ as *const _ as usize },
8746 0usize,
8747 concat!(
8748 "Offset of field: ",
8749 stringify!(spJitterVertexEffect),
8750 "::",
8751 stringify!(super_)
8752 )
8753 );
8754 assert_eq!(
8755 unsafe { &(*(::std::ptr::null::<spJitterVertexEffect>())).jitterX as *const _ as usize },
8756 24usize,
8757 concat!(
8758 "Offset of field: ",
8759 stringify!(spJitterVertexEffect),
8760 "::",
8761 stringify!(jitterX)
8762 )
8763 );
8764 assert_eq!(
8765 unsafe { &(*(::std::ptr::null::<spJitterVertexEffect>())).jitterY as *const _ as usize },
8766 28usize,
8767 concat!(
8768 "Offset of field: ",
8769 stringify!(spJitterVertexEffect),
8770 "::",
8771 stringify!(jitterY)
8772 )
8773 );
8774}
8775#[repr(C)]
8776#[derive(Debug, Copy, Clone)]
8777pub struct spSwirlVertexEffect {
8778 pub super_: spVertexEffect,
8779 pub centerX: f32,
8780 pub centerY: f32,
8781 pub radius: f32,
8782 pub angle: f32,
8783 pub worldX: f32,
8784 pub worldY: f32,
8785}
8786#[test]
8787fn bindgen_test_layout_spSwirlVertexEffect() {
8788 assert_eq!(
8789 ::std::mem::size_of::<spSwirlVertexEffect>(),
8790 48usize,
8791 concat!("Size of: ", stringify!(spSwirlVertexEffect))
8792 );
8793 assert_eq!(
8794 ::std::mem::align_of::<spSwirlVertexEffect>(),
8795 8usize,
8796 concat!("Alignment of ", stringify!(spSwirlVertexEffect))
8797 );
8798 assert_eq!(
8799 unsafe { &(*(::std::ptr::null::<spSwirlVertexEffect>())).super_ as *const _ as usize },
8800 0usize,
8801 concat!(
8802 "Offset of field: ",
8803 stringify!(spSwirlVertexEffect),
8804 "::",
8805 stringify!(super_)
8806 )
8807 );
8808 assert_eq!(
8809 unsafe { &(*(::std::ptr::null::<spSwirlVertexEffect>())).centerX as *const _ as usize },
8810 24usize,
8811 concat!(
8812 "Offset of field: ",
8813 stringify!(spSwirlVertexEffect),
8814 "::",
8815 stringify!(centerX)
8816 )
8817 );
8818 assert_eq!(
8819 unsafe { &(*(::std::ptr::null::<spSwirlVertexEffect>())).centerY as *const _ as usize },
8820 28usize,
8821 concat!(
8822 "Offset of field: ",
8823 stringify!(spSwirlVertexEffect),
8824 "::",
8825 stringify!(centerY)
8826 )
8827 );
8828 assert_eq!(
8829 unsafe { &(*(::std::ptr::null::<spSwirlVertexEffect>())).radius as *const _ as usize },
8830 32usize,
8831 concat!(
8832 "Offset of field: ",
8833 stringify!(spSwirlVertexEffect),
8834 "::",
8835 stringify!(radius)
8836 )
8837 );
8838 assert_eq!(
8839 unsafe { &(*(::std::ptr::null::<spSwirlVertexEffect>())).angle as *const _ as usize },
8840 36usize,
8841 concat!(
8842 "Offset of field: ",
8843 stringify!(spSwirlVertexEffect),
8844 "::",
8845 stringify!(angle)
8846 )
8847 );
8848 assert_eq!(
8849 unsafe { &(*(::std::ptr::null::<spSwirlVertexEffect>())).worldX as *const _ as usize },
8850 40usize,
8851 concat!(
8852 "Offset of field: ",
8853 stringify!(spSwirlVertexEffect),
8854 "::",
8855 stringify!(worldX)
8856 )
8857 );
8858 assert_eq!(
8859 unsafe { &(*(::std::ptr::null::<spSwirlVertexEffect>())).worldY as *const _ as usize },
8860 44usize,
8861 concat!(
8862 "Offset of field: ",
8863 stringify!(spSwirlVertexEffect),
8864 "::",
8865 stringify!(worldY)
8866 )
8867 );
8868}
8869extern "C" {
8870 pub fn spJitterVertexEffect_create(jitterX: f32, jitterY: f32) -> *mut spJitterVertexEffect;
8871}
8872extern "C" {
8873 pub fn spJitterVertexEffect_dispose(effect: *mut spJitterVertexEffect);
8874}
8875extern "C" {
8876 pub fn spSwirlVertexEffect_create(radius: f32) -> *mut spSwirlVertexEffect;
8877}
8878extern "C" {
8879 pub fn spSwirlVertexEffect_dispose(effect: *mut spSwirlVertexEffect);
8880}
8881extern "C" {
8882 pub fn _spReadFile(
8883 path: *const ::std::os::raw::c_char,
8884 length: *mut ::std::os::raw::c_int,
8885 ) -> *mut ::std::os::raw::c_char;
8886}