pub const SKIN_ENTRIES_HASH_TABLE_SIZE: u32 = 100;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spEventData {
pub name: *const ::std::os::raw::c_char,
pub intValue: ::std::os::raw::c_int,
pub floatValue: f32,
pub stringValue: *const ::std::os::raw::c_char,
pub audioPath: *const ::std::os::raw::c_char,
pub volume: f32,
pub balance: f32,
}
#[test]
fn bindgen_test_layout_spEventData() {
assert_eq!(
::std::mem::size_of::<spEventData>(),
40usize,
concat!("Size of: ", stringify!(spEventData))
);
assert_eq!(
::std::mem::align_of::<spEventData>(),
8usize,
concat!("Alignment of ", stringify!(spEventData))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEventData>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spEventData),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEventData>())).intValue as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spEventData),
"::",
stringify!(intValue)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEventData>())).floatValue as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(spEventData),
"::",
stringify!(floatValue)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEventData>())).stringValue as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spEventData),
"::",
stringify!(stringValue)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEventData>())).audioPath as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spEventData),
"::",
stringify!(audioPath)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEventData>())).volume as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spEventData),
"::",
stringify!(volume)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEventData>())).balance as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(spEventData),
"::",
stringify!(balance)
)
);
}
extern "C" {
pub fn spEventData_create(name: *const ::std::os::raw::c_char) -> *mut spEventData;
}
extern "C" {
pub fn spEventData_dispose(self_: *mut spEventData);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spEvent {
pub data: *mut spEventData,
pub time: f32,
pub intValue: ::std::os::raw::c_int,
pub floatValue: f32,
pub stringValue: *const ::std::os::raw::c_char,
pub volume: f32,
pub balance: f32,
}
#[test]
fn bindgen_test_layout_spEvent() {
assert_eq!(
::std::mem::size_of::<spEvent>(),
40usize,
concat!("Size of: ", stringify!(spEvent))
);
assert_eq!(
::std::mem::align_of::<spEvent>(),
8usize,
concat!("Alignment of ", stringify!(spEvent))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEvent>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spEvent),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEvent>())).time as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spEvent),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEvent>())).intValue as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(spEvent),
"::",
stringify!(intValue)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEvent>())).floatValue as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spEvent),
"::",
stringify!(floatValue)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEvent>())).stringValue as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spEvent),
"::",
stringify!(stringValue)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEvent>())).volume as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spEvent),
"::",
stringify!(volume)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEvent>())).balance as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(spEvent),
"::",
stringify!(balance)
)
);
}
extern "C" {
pub fn spEvent_create(time: f32, data: *mut spEventData) -> *mut spEvent;
}
extern "C" {
pub fn spEvent_dispose(self_: *mut spEvent);
}
pub const spAttachmentType_SP_ATTACHMENT_REGION: spAttachmentType = 0;
pub const spAttachmentType_SP_ATTACHMENT_BOUNDING_BOX: spAttachmentType = 1;
pub const spAttachmentType_SP_ATTACHMENT_MESH: spAttachmentType = 2;
pub const spAttachmentType_SP_ATTACHMENT_LINKED_MESH: spAttachmentType = 3;
pub const spAttachmentType_SP_ATTACHMENT_PATH: spAttachmentType = 4;
pub const spAttachmentType_SP_ATTACHMENT_POINT: spAttachmentType = 5;
pub const spAttachmentType_SP_ATTACHMENT_CLIPPING: spAttachmentType = 6;
pub type spAttachmentType = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spAttachment {
pub name: *const ::std::os::raw::c_char,
pub type_: spAttachmentType,
pub vtable: *const ::std::os::raw::c_void,
pub refCount: ::std::os::raw::c_int,
pub attachmentLoader: *mut spAttachmentLoader,
}
#[test]
fn bindgen_test_layout_spAttachment() {
assert_eq!(
::std::mem::size_of::<spAttachment>(),
40usize,
concat!("Size of: ", stringify!(spAttachment))
);
assert_eq!(
::std::mem::align_of::<spAttachment>(),
8usize,
concat!("Alignment of ", stringify!(spAttachment))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAttachment>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spAttachment),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAttachment>())).type_ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spAttachment),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAttachment>())).vtable as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spAttachment),
"::",
stringify!(vtable)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAttachment>())).refCount as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spAttachment),
"::",
stringify!(refCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAttachment>())).attachmentLoader as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spAttachment),
"::",
stringify!(attachmentLoader)
)
);
}
extern "C" {
pub fn spAttachment_dispose(self_: *mut spAttachment);
}
extern "C" {
pub fn spAttachment_copy(self_: *mut spAttachment) -> *mut spAttachment;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spAnimation {
pub name: *const ::std::os::raw::c_char,
pub duration: f32,
pub timelinesCount: ::std::os::raw::c_int,
pub timelines: *mut *mut spTimeline,
}
#[test]
fn bindgen_test_layout_spAnimation() {
assert_eq!(
::std::mem::size_of::<spAnimation>(),
24usize,
concat!("Size of: ", stringify!(spAnimation))
);
assert_eq!(
::std::mem::align_of::<spAnimation>(),
8usize,
concat!("Alignment of ", stringify!(spAnimation))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAnimation>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spAnimation),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAnimation>())).duration as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spAnimation),
"::",
stringify!(duration)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAnimation>())).timelinesCount as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(spAnimation),
"::",
stringify!(timelinesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAnimation>())).timelines as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spAnimation),
"::",
stringify!(timelines)
)
);
}
pub const spMixBlend_SP_MIX_BLEND_SETUP: spMixBlend = 0;
pub const spMixBlend_SP_MIX_BLEND_FIRST: spMixBlend = 1;
pub const spMixBlend_SP_MIX_BLEND_REPLACE: spMixBlend = 2;
pub const spMixBlend_SP_MIX_BLEND_ADD: spMixBlend = 3;
pub type spMixBlend = u32;
pub const spMixDirection_SP_MIX_DIRECTION_IN: spMixDirection = 0;
pub const spMixDirection_SP_MIX_DIRECTION_OUT: spMixDirection = 1;
pub type spMixDirection = u32;
extern "C" {
pub fn spAnimation_create(
name: *const ::std::os::raw::c_char,
timelinesCount: ::std::os::raw::c_int,
) -> *mut spAnimation;
}
extern "C" {
pub fn spAnimation_dispose(self_: *mut spAnimation);
}
extern "C" {
#[doc = " Poses the skeleton at the specified time for this animation."]
#[doc = " @param lastTime The last time the animation was applied."]
#[doc = " @param events Any triggered events are added. May be null."]
pub fn spAnimation_apply(
self_: *const spAnimation,
skeleton: *mut spSkeleton,
lastTime: f32,
time: f32,
loop_: ::std::os::raw::c_int,
events: *mut *mut spEvent,
eventsCount: *mut ::std::os::raw::c_int,
alpha: f32,
blend: spMixBlend,
direction: spMixDirection,
);
}
pub const spTimelineType_SP_TIMELINE_ROTATE: spTimelineType = 0;
pub const spTimelineType_SP_TIMELINE_TRANSLATE: spTimelineType = 1;
pub const spTimelineType_SP_TIMELINE_SCALE: spTimelineType = 2;
pub const spTimelineType_SP_TIMELINE_SHEAR: spTimelineType = 3;
pub const spTimelineType_SP_TIMELINE_ATTACHMENT: spTimelineType = 4;
pub const spTimelineType_SP_TIMELINE_COLOR: spTimelineType = 5;
pub const spTimelineType_SP_TIMELINE_DEFORM: spTimelineType = 6;
pub const spTimelineType_SP_TIMELINE_EVENT: spTimelineType = 7;
pub const spTimelineType_SP_TIMELINE_DRAWORDER: spTimelineType = 8;
pub const spTimelineType_SP_TIMELINE_IKCONSTRAINT: spTimelineType = 9;
pub const spTimelineType_SP_TIMELINE_TRANSFORMCONSTRAINT: spTimelineType = 10;
pub const spTimelineType_SP_TIMELINE_PATHCONSTRAINTPOSITION: spTimelineType = 11;
pub const spTimelineType_SP_TIMELINE_PATHCONSTRAINTSPACING: spTimelineType = 12;
pub const spTimelineType_SP_TIMELINE_PATHCONSTRAINTMIX: spTimelineType = 13;
pub const spTimelineType_SP_TIMELINE_TWOCOLOR: spTimelineType = 14;
pub type spTimelineType = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spTimeline {
pub type_: spTimelineType,
pub vtable: *const ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_spTimeline() {
assert_eq!(
::std::mem::size_of::<spTimeline>(),
16usize,
concat!("Size of: ", stringify!(spTimeline))
);
assert_eq!(
::std::mem::align_of::<spTimeline>(),
8usize,
concat!("Alignment of ", stringify!(spTimeline))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTimeline>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spTimeline),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTimeline>())).vtable as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spTimeline),
"::",
stringify!(vtable)
)
);
}
extern "C" {
pub fn spTimeline_dispose(self_: *mut spTimeline);
}
extern "C" {
pub fn spTimeline_apply(
self_: *const spTimeline,
skeleton: *mut spSkeleton,
lastTime: f32,
time: f32,
firedEvents: *mut *mut spEvent,
eventsCount: *mut ::std::os::raw::c_int,
alpha: f32,
blend: spMixBlend,
direction: spMixDirection,
);
}
extern "C" {
pub fn spTimeline_getPropertyId(self_: *const spTimeline) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spCurveTimeline {
pub super_: spTimeline,
pub curves: *mut f32,
}
#[test]
fn bindgen_test_layout_spCurveTimeline() {
assert_eq!(
::std::mem::size_of::<spCurveTimeline>(),
24usize,
concat!("Size of: ", stringify!(spCurveTimeline))
);
assert_eq!(
::std::mem::align_of::<spCurveTimeline>(),
8usize,
concat!("Alignment of ", stringify!(spCurveTimeline))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spCurveTimeline>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spCurveTimeline),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spCurveTimeline>())).curves as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spCurveTimeline),
"::",
stringify!(curves)
)
);
}
extern "C" {
pub fn spCurveTimeline_setLinear(
self_: *mut spCurveTimeline,
frameIndex: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spCurveTimeline_setStepped(
self_: *mut spCurveTimeline,
frameIndex: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spCurveTimeline_setCurve(
self_: *mut spCurveTimeline,
frameIndex: ::std::os::raw::c_int,
cx1: f32,
cy1: f32,
cx2: f32,
cy2: f32,
);
}
extern "C" {
pub fn spCurveTimeline_getCurvePercent(
self_: *const spCurveTimeline,
frameIndex: ::std::os::raw::c_int,
percent: f32,
) -> f32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spBaseTimeline {
pub super_: spCurveTimeline,
pub framesCount: ::std::os::raw::c_int,
pub frames: *mut f32,
pub boneIndex: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spBaseTimeline() {
assert_eq!(
::std::mem::size_of::<spBaseTimeline>(),
48usize,
concat!("Size of: ", stringify!(spBaseTimeline))
);
assert_eq!(
::std::mem::align_of::<spBaseTimeline>(),
8usize,
concat!("Alignment of ", stringify!(spBaseTimeline))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBaseTimeline>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spBaseTimeline),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBaseTimeline>())).framesCount as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spBaseTimeline),
"::",
stringify!(framesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBaseTimeline>())).frames as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spBaseTimeline),
"::",
stringify!(frames)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBaseTimeline>())).boneIndex as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spBaseTimeline),
"::",
stringify!(boneIndex)
)
);
}
pub const ROTATE_PREV_TIME: ::std::os::raw::c_int = -2;
pub const ROTATE_PREV_ROTATION: ::std::os::raw::c_int = -1;
pub const ROTATE_ROTATION: ::std::os::raw::c_int = 1;
pub const ROTATE_ENTRIES: ::std::os::raw::c_int = 2;
pub type spRotateTimeline = spBaseTimeline;
extern "C" {
pub fn spRotateTimeline_create(framesCount: ::std::os::raw::c_int) -> *mut spRotateTimeline;
}
extern "C" {
pub fn spRotateTimeline_setFrame(
self_: *mut spRotateTimeline,
frameIndex: ::std::os::raw::c_int,
time: f32,
angle: f32,
);
}
pub const TRANSLATE_ENTRIES: ::std::os::raw::c_int = 3;
pub type spTranslateTimeline = spBaseTimeline;
extern "C" {
pub fn spTranslateTimeline_create(
framesCount: ::std::os::raw::c_int,
) -> *mut spTranslateTimeline;
}
extern "C" {
pub fn spTranslateTimeline_setFrame(
self_: *mut spTranslateTimeline,
frameIndex: ::std::os::raw::c_int,
time: f32,
x: f32,
y: f32,
);
}
pub type spScaleTimeline = spBaseTimeline;
extern "C" {
pub fn spScaleTimeline_create(framesCount: ::std::os::raw::c_int) -> *mut spScaleTimeline;
}
extern "C" {
pub fn spScaleTimeline_setFrame(
self_: *mut spScaleTimeline,
frameIndex: ::std::os::raw::c_int,
time: f32,
x: f32,
y: f32,
);
}
pub type spShearTimeline = spBaseTimeline;
extern "C" {
pub fn spShearTimeline_create(framesCount: ::std::os::raw::c_int) -> *mut spShearTimeline;
}
extern "C" {
pub fn spShearTimeline_setFrame(
self_: *mut spShearTimeline,
frameIndex: ::std::os::raw::c_int,
time: f32,
x: f32,
y: f32,
);
}
pub const COLOR_ENTRIES: ::std::os::raw::c_int = 5;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spColorTimeline {
pub super_: spCurveTimeline,
pub framesCount: ::std::os::raw::c_int,
pub frames: *mut f32,
pub slotIndex: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spColorTimeline() {
assert_eq!(
::std::mem::size_of::<spColorTimeline>(),
48usize,
concat!("Size of: ", stringify!(spColorTimeline))
);
assert_eq!(
::std::mem::align_of::<spColorTimeline>(),
8usize,
concat!("Alignment of ", stringify!(spColorTimeline))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spColorTimeline>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spColorTimeline),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spColorTimeline>())).framesCount as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spColorTimeline),
"::",
stringify!(framesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spColorTimeline>())).frames as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spColorTimeline),
"::",
stringify!(frames)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spColorTimeline>())).slotIndex as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spColorTimeline),
"::",
stringify!(slotIndex)
)
);
}
extern "C" {
pub fn spColorTimeline_create(framesCount: ::std::os::raw::c_int) -> *mut spColorTimeline;
}
extern "C" {
pub fn spColorTimeline_setFrame(
self_: *mut spColorTimeline,
frameIndex: ::std::os::raw::c_int,
time: f32,
r: f32,
g: f32,
b: f32,
a: f32,
);
}
pub const TWOCOLOR_ENTRIES: ::std::os::raw::c_int = 8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spTwoColorTimeline {
pub super_: spCurveTimeline,
pub framesCount: ::std::os::raw::c_int,
pub frames: *mut f32,
pub slotIndex: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spTwoColorTimeline() {
assert_eq!(
::std::mem::size_of::<spTwoColorTimeline>(),
48usize,
concat!("Size of: ", stringify!(spTwoColorTimeline))
);
assert_eq!(
::std::mem::align_of::<spTwoColorTimeline>(),
8usize,
concat!("Alignment of ", stringify!(spTwoColorTimeline))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTwoColorTimeline>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spTwoColorTimeline),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTwoColorTimeline>())).framesCount as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spTwoColorTimeline),
"::",
stringify!(framesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTwoColorTimeline>())).frames as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spTwoColorTimeline),
"::",
stringify!(frames)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTwoColorTimeline>())).slotIndex as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spTwoColorTimeline),
"::",
stringify!(slotIndex)
)
);
}
extern "C" {
pub fn spTwoColorTimeline_create(framesCount: ::std::os::raw::c_int)
-> *mut spTwoColorTimeline;
}
extern "C" {
pub fn spTwoColorTimeline_setFrame(
self_: *mut spTwoColorTimeline,
frameIndex: ::std::os::raw::c_int,
time: f32,
r: f32,
g: f32,
b: f32,
a: f32,
r2: f32,
g2: f32,
b2: f32,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spAttachmentTimeline {
pub super_: spTimeline,
pub framesCount: ::std::os::raw::c_int,
pub frames: *mut f32,
pub slotIndex: ::std::os::raw::c_int,
pub attachmentNames: *mut *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_spAttachmentTimeline() {
assert_eq!(
::std::mem::size_of::<spAttachmentTimeline>(),
48usize,
concat!("Size of: ", stringify!(spAttachmentTimeline))
);
assert_eq!(
::std::mem::align_of::<spAttachmentTimeline>(),
8usize,
concat!("Alignment of ", stringify!(spAttachmentTimeline))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAttachmentTimeline>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spAttachmentTimeline),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spAttachmentTimeline>())).framesCount as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(spAttachmentTimeline),
"::",
stringify!(framesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAttachmentTimeline>())).frames as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spAttachmentTimeline),
"::",
stringify!(frames)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAttachmentTimeline>())).slotIndex as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spAttachmentTimeline),
"::",
stringify!(slotIndex)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spAttachmentTimeline>())).attachmentNames as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(spAttachmentTimeline),
"::",
stringify!(attachmentNames)
)
);
}
extern "C" {
pub fn spAttachmentTimeline_create(
framesCount: ::std::os::raw::c_int,
) -> *mut spAttachmentTimeline;
}
extern "C" {
pub fn spAttachmentTimeline_setFrame(
self_: *mut spAttachmentTimeline,
frameIndex: ::std::os::raw::c_int,
time: f32,
attachmentName: *const ::std::os::raw::c_char,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spEventTimeline {
pub super_: spTimeline,
pub framesCount: ::std::os::raw::c_int,
pub frames: *mut f32,
pub events: *mut *mut spEvent,
}
#[test]
fn bindgen_test_layout_spEventTimeline() {
assert_eq!(
::std::mem::size_of::<spEventTimeline>(),
40usize,
concat!("Size of: ", stringify!(spEventTimeline))
);
assert_eq!(
::std::mem::align_of::<spEventTimeline>(),
8usize,
concat!("Alignment of ", stringify!(spEventTimeline))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEventTimeline>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spEventTimeline),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEventTimeline>())).framesCount as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spEventTimeline),
"::",
stringify!(framesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEventTimeline>())).frames as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spEventTimeline),
"::",
stringify!(frames)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spEventTimeline>())).events as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spEventTimeline),
"::",
stringify!(events)
)
);
}
extern "C" {
pub fn spEventTimeline_create(framesCount: ::std::os::raw::c_int) -> *mut spEventTimeline;
}
extern "C" {
pub fn spEventTimeline_setFrame(
self_: *mut spEventTimeline,
frameIndex: ::std::os::raw::c_int,
event: *mut spEvent,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spDrawOrderTimeline {
pub super_: spTimeline,
pub framesCount: ::std::os::raw::c_int,
pub frames: *mut f32,
pub drawOrders: *mut *const ::std::os::raw::c_int,
pub slotsCount: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spDrawOrderTimeline() {
assert_eq!(
::std::mem::size_of::<spDrawOrderTimeline>(),
48usize,
concat!("Size of: ", stringify!(spDrawOrderTimeline))
);
assert_eq!(
::std::mem::align_of::<spDrawOrderTimeline>(),
8usize,
concat!("Alignment of ", stringify!(spDrawOrderTimeline))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spDrawOrderTimeline>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spDrawOrderTimeline),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spDrawOrderTimeline>())).framesCount as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spDrawOrderTimeline),
"::",
stringify!(framesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spDrawOrderTimeline>())).frames as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spDrawOrderTimeline),
"::",
stringify!(frames)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spDrawOrderTimeline>())).drawOrders as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spDrawOrderTimeline),
"::",
stringify!(drawOrders)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spDrawOrderTimeline>())).slotsCount as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spDrawOrderTimeline),
"::",
stringify!(slotsCount)
)
);
}
extern "C" {
pub fn spDrawOrderTimeline_create(
framesCount: ::std::os::raw::c_int,
slotsCount: ::std::os::raw::c_int,
) -> *mut spDrawOrderTimeline;
}
extern "C" {
pub fn spDrawOrderTimeline_setFrame(
self_: *mut spDrawOrderTimeline,
frameIndex: ::std::os::raw::c_int,
time: f32,
drawOrder: *const ::std::os::raw::c_int,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spDeformTimeline {
pub super_: spCurveTimeline,
pub framesCount: ::std::os::raw::c_int,
pub frames: *mut f32,
pub frameVerticesCount: ::std::os::raw::c_int,
pub frameVertices: *mut *const f32,
pub slotIndex: ::std::os::raw::c_int,
pub attachment: *mut spAttachment,
}
#[test]
fn bindgen_test_layout_spDeformTimeline() {
assert_eq!(
::std::mem::size_of::<spDeformTimeline>(),
72usize,
concat!("Size of: ", stringify!(spDeformTimeline))
);
assert_eq!(
::std::mem::align_of::<spDeformTimeline>(),
8usize,
concat!("Alignment of ", stringify!(spDeformTimeline))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spDeformTimeline>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spDeformTimeline),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spDeformTimeline>())).framesCount as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spDeformTimeline),
"::",
stringify!(framesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spDeformTimeline>())).frames as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spDeformTimeline),
"::",
stringify!(frames)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spDeformTimeline>())).frameVerticesCount as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(spDeformTimeline),
"::",
stringify!(frameVerticesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spDeformTimeline>())).frameVertices as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spDeformTimeline),
"::",
stringify!(frameVertices)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spDeformTimeline>())).slotIndex as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(spDeformTimeline),
"::",
stringify!(slotIndex)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spDeformTimeline>())).attachment as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(spDeformTimeline),
"::",
stringify!(attachment)
)
);
}
extern "C" {
pub fn spDeformTimeline_create(
framesCount: ::std::os::raw::c_int,
frameVerticesCount: ::std::os::raw::c_int,
) -> *mut spDeformTimeline;
}
extern "C" {
pub fn spDeformTimeline_setFrame(
self_: *mut spDeformTimeline,
frameIndex: ::std::os::raw::c_int,
time: f32,
vertices: *mut f32,
);
}
pub const IKCONSTRAINT_ENTRIES: ::std::os::raw::c_int = 6;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spIkConstraintTimeline {
pub super_: spCurveTimeline,
pub framesCount: ::std::os::raw::c_int,
pub frames: *mut f32,
pub ikConstraintIndex: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spIkConstraintTimeline() {
assert_eq!(
::std::mem::size_of::<spIkConstraintTimeline>(),
48usize,
concat!("Size of: ", stringify!(spIkConstraintTimeline))
);
assert_eq!(
::std::mem::align_of::<spIkConstraintTimeline>(),
8usize,
concat!("Alignment of ", stringify!(spIkConstraintTimeline))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraintTimeline>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintTimeline),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spIkConstraintTimeline>())).framesCount as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintTimeline),
"::",
stringify!(framesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraintTimeline>())).frames as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintTimeline),
"::",
stringify!(frames)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spIkConstraintTimeline>())).ikConstraintIndex as *const _
as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintTimeline),
"::",
stringify!(ikConstraintIndex)
)
);
}
extern "C" {
pub fn spIkConstraintTimeline_create(
framesCount: ::std::os::raw::c_int,
) -> *mut spIkConstraintTimeline;
}
extern "C" {
pub fn spIkConstraintTimeline_setFrame(
self_: *mut spIkConstraintTimeline,
frameIndex: ::std::os::raw::c_int,
time: f32,
mix: f32,
softness: f32,
bendDirection: ::std::os::raw::c_int,
compress: ::std::os::raw::c_int,
stretch: ::std::os::raw::c_int,
);
}
pub const TRANSFORMCONSTRAINT_ENTRIES: ::std::os::raw::c_int = 5;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spTransformConstraintTimeline {
pub super_: spCurveTimeline,
pub framesCount: ::std::os::raw::c_int,
pub frames: *mut f32,
pub transformConstraintIndex: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spTransformConstraintTimeline() {
assert_eq!(
::std::mem::size_of::<spTransformConstraintTimeline>(),
48usize,
concat!("Size of: ", stringify!(spTransformConstraintTimeline))
);
assert_eq!(
::std::mem::align_of::<spTransformConstraintTimeline>(),
8usize,
concat!("Alignment of ", stringify!(spTransformConstraintTimeline))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintTimeline>())).super_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintTimeline),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintTimeline>())).framesCount as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintTimeline),
"::",
stringify!(framesCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintTimeline>())).frames as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintTimeline),
"::",
stringify!(frames)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintTimeline>())).transformConstraintIndex
as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintTimeline),
"::",
stringify!(transformConstraintIndex)
)
);
}
extern "C" {
pub fn spTransformConstraintTimeline_create(
framesCount: ::std::os::raw::c_int,
) -> *mut spTransformConstraintTimeline;
}
extern "C" {
pub fn spTransformConstraintTimeline_setFrame(
self_: *mut spTransformConstraintTimeline,
frameIndex: ::std::os::raw::c_int,
time: f32,
rotateMix: f32,
translateMix: f32,
scaleMix: f32,
shearMix: f32,
);
}
pub const PATHCONSTRAINTPOSITION_ENTRIES: ::std::os::raw::c_int = 2;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spPathConstraintPositionTimeline {
pub super_: spCurveTimeline,
pub framesCount: ::std::os::raw::c_int,
pub frames: *mut f32,
pub pathConstraintIndex: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spPathConstraintPositionTimeline() {
assert_eq!(
::std::mem::size_of::<spPathConstraintPositionTimeline>(),
48usize,
concat!("Size of: ", stringify!(spPathConstraintPositionTimeline))
);
assert_eq!(
::std::mem::align_of::<spPathConstraintPositionTimeline>(),
8usize,
concat!(
"Alignment of ",
stringify!(spPathConstraintPositionTimeline)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintPositionTimeline>())).super_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintPositionTimeline),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintPositionTimeline>())).framesCount as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintPositionTimeline),
"::",
stringify!(framesCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintPositionTimeline>())).frames as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintPositionTimeline),
"::",
stringify!(frames)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintPositionTimeline>())).pathConstraintIndex
as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintPositionTimeline),
"::",
stringify!(pathConstraintIndex)
)
);
}
extern "C" {
pub fn spPathConstraintPositionTimeline_create(
framesCount: ::std::os::raw::c_int,
) -> *mut spPathConstraintPositionTimeline;
}
extern "C" {
pub fn spPathConstraintPositionTimeline_setFrame(
self_: *mut spPathConstraintPositionTimeline,
frameIndex: ::std::os::raw::c_int,
time: f32,
value: f32,
);
}
pub const PATHCONSTRAINTSPACING_ENTRIES: ::std::os::raw::c_int = 2;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spPathConstraintSpacingTimeline {
pub super_: spCurveTimeline,
pub framesCount: ::std::os::raw::c_int,
pub frames: *mut f32,
pub pathConstraintIndex: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spPathConstraintSpacingTimeline() {
assert_eq!(
::std::mem::size_of::<spPathConstraintSpacingTimeline>(),
48usize,
concat!("Size of: ", stringify!(spPathConstraintSpacingTimeline))
);
assert_eq!(
::std::mem::align_of::<spPathConstraintSpacingTimeline>(),
8usize,
concat!("Alignment of ", stringify!(spPathConstraintSpacingTimeline))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintSpacingTimeline>())).super_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintSpacingTimeline),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintSpacingTimeline>())).framesCount as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintSpacingTimeline),
"::",
stringify!(framesCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintSpacingTimeline>())).frames as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintSpacingTimeline),
"::",
stringify!(frames)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintSpacingTimeline>())).pathConstraintIndex
as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintSpacingTimeline),
"::",
stringify!(pathConstraintIndex)
)
);
}
extern "C" {
pub fn spPathConstraintSpacingTimeline_create(
framesCount: ::std::os::raw::c_int,
) -> *mut spPathConstraintSpacingTimeline;
}
extern "C" {
pub fn spPathConstraintSpacingTimeline_setFrame(
self_: *mut spPathConstraintSpacingTimeline,
frameIndex: ::std::os::raw::c_int,
time: f32,
value: f32,
);
}
pub const PATHCONSTRAINTMIX_ENTRIES: ::std::os::raw::c_int = 3;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spPathConstraintMixTimeline {
pub super_: spCurveTimeline,
pub framesCount: ::std::os::raw::c_int,
pub frames: *mut f32,
pub pathConstraintIndex: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spPathConstraintMixTimeline() {
assert_eq!(
::std::mem::size_of::<spPathConstraintMixTimeline>(),
48usize,
concat!("Size of: ", stringify!(spPathConstraintMixTimeline))
);
assert_eq!(
::std::mem::align_of::<spPathConstraintMixTimeline>(),
8usize,
concat!("Alignment of ", stringify!(spPathConstraintMixTimeline))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintMixTimeline>())).super_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintMixTimeline),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintMixTimeline>())).framesCount as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintMixTimeline),
"::",
stringify!(framesCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintMixTimeline>())).frames as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintMixTimeline),
"::",
stringify!(frames)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintMixTimeline>())).pathConstraintIndex as *const _
as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintMixTimeline),
"::",
stringify!(pathConstraintIndex)
)
);
}
extern "C" {
pub fn spPathConstraintMixTimeline_create(
framesCount: ::std::os::raw::c_int,
) -> *mut spPathConstraintMixTimeline;
}
extern "C" {
pub fn spPathConstraintMixTimeline_setFrame(
self_: *mut spPathConstraintMixTimeline,
frameIndex: ::std::os::raw::c_int,
time: f32,
rotateMix: f32,
translateMix: f32,
);
}
pub const spTransformMode_SP_TRANSFORMMODE_NORMAL: spTransformMode = 0;
pub const spTransformMode_SP_TRANSFORMMODE_ONLYTRANSLATION: spTransformMode = 1;
pub const spTransformMode_SP_TRANSFORMMODE_NOROTATIONORREFLECTION: spTransformMode = 2;
pub const spTransformMode_SP_TRANSFORMMODE_NOSCALE: spTransformMode = 3;
pub const spTransformMode_SP_TRANSFORMMODE_NOSCALEORREFLECTION: spTransformMode = 4;
pub type spTransformMode = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spBoneData {
pub index: ::std::os::raw::c_int,
pub name: *const ::std::os::raw::c_char,
pub parent: *mut spBoneData,
pub length: f32,
pub x: f32,
pub y: f32,
pub rotation: f32,
pub scaleX: f32,
pub scaleY: f32,
pub shearX: f32,
pub shearY: f32,
pub transformMode: spTransformMode,
pub skinRequired: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spBoneData() {
assert_eq!(
::std::mem::size_of::<spBoneData>(),
64usize,
concat!("Size of: ", stringify!(spBoneData))
);
assert_eq!(
::std::mem::align_of::<spBoneData>(),
8usize,
concat!("Alignment of ", stringify!(spBoneData))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoneData>())).index as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spBoneData),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoneData>())).name as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spBoneData),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoneData>())).parent as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spBoneData),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoneData>())).length as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spBoneData),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoneData>())).x as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(spBoneData),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoneData>())).y as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spBoneData),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoneData>())).rotation as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(spBoneData),
"::",
stringify!(rotation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoneData>())).scaleX as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spBoneData),
"::",
stringify!(scaleX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoneData>())).scaleY as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(spBoneData),
"::",
stringify!(scaleY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoneData>())).shearX as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spBoneData),
"::",
stringify!(shearX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoneData>())).shearY as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(spBoneData),
"::",
stringify!(shearY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoneData>())).transformMode as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(spBoneData),
"::",
stringify!(transformMode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoneData>())).skinRequired as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(spBoneData),
"::",
stringify!(skinRequired)
)
);
}
extern "C" {
pub fn spBoneData_create(
index: ::std::os::raw::c_int,
name: *const ::std::os::raw::c_char,
parent: *mut spBoneData,
) -> *mut spBoneData;
}
extern "C" {
pub fn spBoneData_dispose(self_: *mut spBoneData);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spColor {
pub r: f32,
pub g: f32,
pub b: f32,
pub a: f32,
}
#[test]
fn bindgen_test_layout_spColor() {
assert_eq!(
::std::mem::size_of::<spColor>(),
16usize,
concat!("Size of: ", stringify!(spColor))
);
assert_eq!(
::std::mem::align_of::<spColor>(),
4usize,
concat!("Alignment of ", stringify!(spColor))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spColor>())).r as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spColor),
"::",
stringify!(r)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spColor>())).g as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spColor),
"::",
stringify!(g)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spColor>())).b as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spColor),
"::",
stringify!(b)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spColor>())).a as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(spColor),
"::",
stringify!(a)
)
);
}
extern "C" {
pub fn spColor_create() -> *mut spColor;
}
extern "C" {
pub fn spColor_dispose(self_: *mut spColor);
}
extern "C" {
pub fn spColor_setFromFloats(color: *mut spColor, r: f32, g: f32, b: f32, a: f32);
}
extern "C" {
pub fn spColor_setFromColor(color: *mut spColor, otherColor: *mut spColor);
}
extern "C" {
pub fn spColor_addFloats(color: *mut spColor, r: f32, g: f32, b: f32, a: f32);
}
extern "C" {
pub fn spColor_addColor(color: *mut spColor, otherColor: *mut spColor);
}
extern "C" {
pub fn spColor_clamp(color: *mut spColor);
}
pub const spBlendMode_SP_BLEND_MODE_NORMAL: spBlendMode = 0;
pub const spBlendMode_SP_BLEND_MODE_ADDITIVE: spBlendMode = 1;
pub const spBlendMode_SP_BLEND_MODE_MULTIPLY: spBlendMode = 2;
pub const spBlendMode_SP_BLEND_MODE_SCREEN: spBlendMode = 3;
pub type spBlendMode = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spSlotData {
pub index: ::std::os::raw::c_int,
pub name: *const ::std::os::raw::c_char,
pub boneData: *const spBoneData,
pub attachmentName: *const ::std::os::raw::c_char,
pub color: spColor,
pub darkColor: *mut spColor,
pub blendMode: spBlendMode,
}
#[test]
fn bindgen_test_layout_spSlotData() {
assert_eq!(
::std::mem::size_of::<spSlotData>(),
64usize,
concat!("Size of: ", stringify!(spSlotData))
);
assert_eq!(
::std::mem::align_of::<spSlotData>(),
8usize,
concat!("Alignment of ", stringify!(spSlotData))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSlotData>())).index as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spSlotData),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSlotData>())).name as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spSlotData),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSlotData>())).boneData as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spSlotData),
"::",
stringify!(boneData)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSlotData>())).attachmentName as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spSlotData),
"::",
stringify!(attachmentName)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSlotData>())).color as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spSlotData),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSlotData>())).darkColor as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spSlotData),
"::",
stringify!(darkColor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSlotData>())).blendMode as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(spSlotData),
"::",
stringify!(blendMode)
)
);
}
extern "C" {
pub fn spSlotData_create(
index: ::std::os::raw::c_int,
name: *const ::std::os::raw::c_char,
boneData: *mut spBoneData,
) -> *mut spSlotData;
}
extern "C" {
pub fn spSlotData_dispose(self_: *mut spSlotData);
}
extern "C" {
pub fn spSlotData_setAttachmentName(
self_: *mut spSlotData,
attachmentName: *const ::std::os::raw::c_char,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spIkConstraintData {
pub name: *const ::std::os::raw::c_char,
pub order: ::std::os::raw::c_int,
pub skinRequired: ::std::os::raw::c_int,
pub bonesCount: ::std::os::raw::c_int,
pub bones: *mut *mut spBoneData,
pub target: *mut spBoneData,
pub bendDirection: ::std::os::raw::c_int,
pub compress: ::std::os::raw::c_int,
pub stretch: ::std::os::raw::c_int,
pub uniform: ::std::os::raw::c_int,
pub mix: f32,
pub softness: f32,
}
#[test]
fn bindgen_test_layout_spIkConstraintData() {
assert_eq!(
::std::mem::size_of::<spIkConstraintData>(),
64usize,
concat!("Size of: ", stringify!(spIkConstraintData))
);
assert_eq!(
::std::mem::align_of::<spIkConstraintData>(),
8usize,
concat!("Alignment of ", stringify!(spIkConstraintData))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintData),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).order as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintData),
"::",
stringify!(order)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).skinRequired as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintData),
"::",
stringify!(skinRequired)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).bonesCount as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintData),
"::",
stringify!(bonesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).bones as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintData),
"::",
stringify!(bones)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).target as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintData),
"::",
stringify!(target)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spIkConstraintData>())).bendDirection as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintData),
"::",
stringify!(bendDirection)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).compress as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintData),
"::",
stringify!(compress)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).stretch as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintData),
"::",
stringify!(stretch)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).uniform as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintData),
"::",
stringify!(uniform)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).mix as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintData),
"::",
stringify!(mix)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraintData>())).softness as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintData),
"::",
stringify!(softness)
)
);
}
extern "C" {
pub fn spIkConstraintData_create(
name: *const ::std::os::raw::c_char,
) -> *mut spIkConstraintData;
}
extern "C" {
pub fn spIkConstraintData_dispose(self_: *mut spIkConstraintData);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spTransformConstraintData {
pub name: *const ::std::os::raw::c_char,
pub order: ::std::os::raw::c_int,
pub skinRequired: ::std::os::raw::c_int,
pub bonesCount: ::std::os::raw::c_int,
pub bones: *mut *mut spBoneData,
pub target: *mut spBoneData,
pub rotateMix: f32,
pub translateMix: f32,
pub scaleMix: f32,
pub shearMix: f32,
pub offsetRotation: f32,
pub offsetX: f32,
pub offsetY: f32,
pub offsetScaleX: f32,
pub offsetScaleY: f32,
pub offsetShearY: f32,
pub relative: ::std::os::raw::c_int,
pub local: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spTransformConstraintData() {
assert_eq!(
::std::mem::size_of::<spTransformConstraintData>(),
88usize,
concat!("Size of: ", stringify!(spTransformConstraintData))
);
assert_eq!(
::std::mem::align_of::<spTransformConstraintData>(),
8usize,
concat!("Alignment of ", stringify!(spTransformConstraintData))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTransformConstraintData>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTransformConstraintData>())).order as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(order)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintData>())).skinRequired as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(skinRequired)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintData>())).bonesCount as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(bonesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTransformConstraintData>())).bones as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(bones)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintData>())).target as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(target)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintData>())).rotateMix as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(rotateMix)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintData>())).translateMix as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(translateMix)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintData>())).scaleMix as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(scaleMix)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintData>())).shearMix as *const _ as usize
},
52usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(shearMix)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintData>())).offsetRotation as *const _
as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(offsetRotation)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintData>())).offsetX as *const _ as usize
},
60usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(offsetX)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintData>())).offsetY as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(offsetY)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintData>())).offsetScaleX as *const _ as usize
},
68usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(offsetScaleX)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintData>())).offsetScaleY as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(offsetScaleY)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintData>())).offsetShearY as *const _ as usize
},
76usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(offsetShearY)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintData>())).relative as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(relative)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTransformConstraintData>())).local as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintData),
"::",
stringify!(local)
)
);
}
extern "C" {
pub fn spTransformConstraintData_create(
name: *const ::std::os::raw::c_char,
) -> *mut spTransformConstraintData;
}
extern "C" {
pub fn spTransformConstraintData_dispose(self_: *mut spTransformConstraintData);
}
pub const spPositionMode_SP_POSITION_MODE_FIXED: spPositionMode = 0;
pub const spPositionMode_SP_POSITION_MODE_PERCENT: spPositionMode = 1;
pub type spPositionMode = u32;
pub const spSpacingMode_SP_SPACING_MODE_LENGTH: spSpacingMode = 0;
pub const spSpacingMode_SP_SPACING_MODE_FIXED: spSpacingMode = 1;
pub const spSpacingMode_SP_SPACING_MODE_PERCENT: spSpacingMode = 2;
pub type spSpacingMode = u32;
pub const spRotateMode_SP_ROTATE_MODE_TANGENT: spRotateMode = 0;
pub const spRotateMode_SP_ROTATE_MODE_CHAIN: spRotateMode = 1;
pub const spRotateMode_SP_ROTATE_MODE_CHAIN_SCALE: spRotateMode = 2;
pub type spRotateMode = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spPathConstraintData {
pub name: *const ::std::os::raw::c_char,
pub order: ::std::os::raw::c_int,
pub skinRequired: ::std::os::raw::c_int,
pub bonesCount: ::std::os::raw::c_int,
pub bones: *mut *mut spBoneData,
pub target: *mut spSlotData,
pub positionMode: spPositionMode,
pub spacingMode: spSpacingMode,
pub rotateMode: spRotateMode,
pub offsetRotation: f32,
pub position: f32,
pub spacing: f32,
pub rotateMix: f32,
pub translateMix: f32,
}
#[test]
fn bindgen_test_layout_spPathConstraintData() {
assert_eq!(
::std::mem::size_of::<spPathConstraintData>(),
72usize,
concat!("Size of: ", stringify!(spPathConstraintData))
);
assert_eq!(
::std::mem::align_of::<spPathConstraintData>(),
8usize,
concat!("Alignment of ", stringify!(spPathConstraintData))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintData),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).order as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintData),
"::",
stringify!(order)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintData>())).skinRequired as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintData),
"::",
stringify!(skinRequired)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).bonesCount as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintData),
"::",
stringify!(bonesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).bones as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintData),
"::",
stringify!(bones)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).target as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintData),
"::",
stringify!(target)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintData>())).positionMode as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintData),
"::",
stringify!(positionMode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintData>())).spacingMode as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintData),
"::",
stringify!(spacingMode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).rotateMode as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintData),
"::",
stringify!(rotateMode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintData>())).offsetRotation as *const _ as usize
},
52usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintData),
"::",
stringify!(offsetRotation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).position as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintData),
"::",
stringify!(position)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).spacing as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintData),
"::",
stringify!(spacing)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraintData>())).rotateMix as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintData),
"::",
stringify!(rotateMix)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintData>())).translateMix as *const _ as usize
},
68usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintData),
"::",
stringify!(translateMix)
)
);
}
extern "C" {
pub fn spPathConstraintData_create(
name: *const ::std::os::raw::c_char,
) -> *mut spPathConstraintData;
}
extern "C" {
pub fn spPathConstraintData_dispose(self_: *mut spPathConstraintData);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spFloatArray {
pub size: ::std::os::raw::c_int,
pub capacity: ::std::os::raw::c_int,
pub items: *mut f32,
}
#[test]
fn bindgen_test_layout_spFloatArray() {
assert_eq!(
::std::mem::size_of::<spFloatArray>(),
16usize,
concat!("Size of: ", stringify!(spFloatArray))
);
assert_eq!(
::std::mem::align_of::<spFloatArray>(),
8usize,
concat!("Alignment of ", stringify!(spFloatArray))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spFloatArray>())).size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spFloatArray),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spFloatArray>())).capacity as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spFloatArray),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spFloatArray>())).items as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spFloatArray),
"::",
stringify!(items)
)
);
}
extern "C" {
pub fn spFloatArray_create(initialCapacity: ::std::os::raw::c_int) -> *mut spFloatArray;
}
extern "C" {
pub fn spFloatArray_dispose(self_: *mut spFloatArray);
}
extern "C" {
pub fn spFloatArray_clear(self_: *mut spFloatArray);
}
extern "C" {
pub fn spFloatArray_setSize(
self_: *mut spFloatArray,
newSize: ::std::os::raw::c_int,
) -> *mut spFloatArray;
}
extern "C" {
pub fn spFloatArray_ensureCapacity(
self_: *mut spFloatArray,
newCapacity: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spFloatArray_add(self_: *mut spFloatArray, value: f32);
}
extern "C" {
pub fn spFloatArray_addAll(self_: *mut spFloatArray, other: *mut spFloatArray);
}
extern "C" {
pub fn spFloatArray_addAllValues(
self_: *mut spFloatArray,
values: *mut f32,
offset: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spFloatArray_removeAt(self_: *mut spFloatArray, index: ::std::os::raw::c_int);
}
extern "C" {
pub fn spFloatArray_contains(self_: *mut spFloatArray, value: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spFloatArray_pop(self_: *mut spFloatArray) -> f32;
}
extern "C" {
pub fn spFloatArray_peek(self_: *mut spFloatArray) -> f32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spIntArray {
pub size: ::std::os::raw::c_int,
pub capacity: ::std::os::raw::c_int,
pub items: *mut ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spIntArray() {
assert_eq!(
::std::mem::size_of::<spIntArray>(),
16usize,
concat!("Size of: ", stringify!(spIntArray))
);
assert_eq!(
::std::mem::align_of::<spIntArray>(),
8usize,
concat!("Alignment of ", stringify!(spIntArray))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIntArray>())).size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spIntArray),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIntArray>())).capacity as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spIntArray),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIntArray>())).items as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spIntArray),
"::",
stringify!(items)
)
);
}
extern "C" {
pub fn spIntArray_create(initialCapacity: ::std::os::raw::c_int) -> *mut spIntArray;
}
extern "C" {
pub fn spIntArray_dispose(self_: *mut spIntArray);
}
extern "C" {
pub fn spIntArray_clear(self_: *mut spIntArray);
}
extern "C" {
pub fn spIntArray_setSize(
self_: *mut spIntArray,
newSize: ::std::os::raw::c_int,
) -> *mut spIntArray;
}
extern "C" {
pub fn spIntArray_ensureCapacity(self_: *mut spIntArray, newCapacity: ::std::os::raw::c_int);
}
extern "C" {
pub fn spIntArray_add(self_: *mut spIntArray, value: ::std::os::raw::c_int);
}
extern "C" {
pub fn spIntArray_addAll(self_: *mut spIntArray, other: *mut spIntArray);
}
extern "C" {
pub fn spIntArray_addAllValues(
self_: *mut spIntArray,
values: *mut ::std::os::raw::c_int,
offset: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spIntArray_removeAt(self_: *mut spIntArray, index: ::std::os::raw::c_int);
}
extern "C" {
pub fn spIntArray_contains(
self_: *mut spIntArray,
value: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spIntArray_pop(self_: *mut spIntArray) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spIntArray_peek(self_: *mut spIntArray) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spShortArray {
pub size: ::std::os::raw::c_int,
pub capacity: ::std::os::raw::c_int,
pub items: *mut ::std::os::raw::c_short,
}
#[test]
fn bindgen_test_layout_spShortArray() {
assert_eq!(
::std::mem::size_of::<spShortArray>(),
16usize,
concat!("Size of: ", stringify!(spShortArray))
);
assert_eq!(
::std::mem::align_of::<spShortArray>(),
8usize,
concat!("Alignment of ", stringify!(spShortArray))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spShortArray>())).size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spShortArray),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spShortArray>())).capacity as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spShortArray),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spShortArray>())).items as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spShortArray),
"::",
stringify!(items)
)
);
}
extern "C" {
pub fn spShortArray_create(initialCapacity: ::std::os::raw::c_int) -> *mut spShortArray;
}
extern "C" {
pub fn spShortArray_dispose(self_: *mut spShortArray);
}
extern "C" {
pub fn spShortArray_clear(self_: *mut spShortArray);
}
extern "C" {
pub fn spShortArray_setSize(
self_: *mut spShortArray,
newSize: ::std::os::raw::c_int,
) -> *mut spShortArray;
}
extern "C" {
pub fn spShortArray_ensureCapacity(
self_: *mut spShortArray,
newCapacity: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spShortArray_add(self_: *mut spShortArray, value: ::std::os::raw::c_short);
}
extern "C" {
pub fn spShortArray_addAll(self_: *mut spShortArray, other: *mut spShortArray);
}
extern "C" {
pub fn spShortArray_addAllValues(
self_: *mut spShortArray,
values: *mut ::std::os::raw::c_short,
offset: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spShortArray_removeAt(self_: *mut spShortArray, index: ::std::os::raw::c_int);
}
extern "C" {
pub fn spShortArray_contains(
self_: *mut spShortArray,
value: ::std::os::raw::c_short,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spShortArray_pop(self_: *mut spShortArray) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn spShortArray_peek(self_: *mut spShortArray) -> ::std::os::raw::c_short;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spUnsignedShortArray {
pub size: ::std::os::raw::c_int,
pub capacity: ::std::os::raw::c_int,
pub items: *mut ::std::os::raw::c_ushort,
}
#[test]
fn bindgen_test_layout_spUnsignedShortArray() {
assert_eq!(
::std::mem::size_of::<spUnsignedShortArray>(),
16usize,
concat!("Size of: ", stringify!(spUnsignedShortArray))
);
assert_eq!(
::std::mem::align_of::<spUnsignedShortArray>(),
8usize,
concat!("Alignment of ", stringify!(spUnsignedShortArray))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spUnsignedShortArray>())).size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spUnsignedShortArray),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spUnsignedShortArray>())).capacity as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spUnsignedShortArray),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spUnsignedShortArray>())).items as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spUnsignedShortArray),
"::",
stringify!(items)
)
);
}
extern "C" {
pub fn spUnsignedShortArray_create(
initialCapacity: ::std::os::raw::c_int,
) -> *mut spUnsignedShortArray;
}
extern "C" {
pub fn spUnsignedShortArray_dispose(self_: *mut spUnsignedShortArray);
}
extern "C" {
pub fn spUnsignedShortArray_clear(self_: *mut spUnsignedShortArray);
}
extern "C" {
pub fn spUnsignedShortArray_setSize(
self_: *mut spUnsignedShortArray,
newSize: ::std::os::raw::c_int,
) -> *mut spUnsignedShortArray;
}
extern "C" {
pub fn spUnsignedShortArray_ensureCapacity(
self_: *mut spUnsignedShortArray,
newCapacity: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spUnsignedShortArray_add(
self_: *mut spUnsignedShortArray,
value: ::std::os::raw::c_ushort,
);
}
extern "C" {
pub fn spUnsignedShortArray_addAll(
self_: *mut spUnsignedShortArray,
other: *mut spUnsignedShortArray,
);
}
extern "C" {
pub fn spUnsignedShortArray_addAllValues(
self_: *mut spUnsignedShortArray,
values: *mut ::std::os::raw::c_ushort,
offset: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spUnsignedShortArray_removeAt(
self_: *mut spUnsignedShortArray,
index: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spUnsignedShortArray_contains(
self_: *mut spUnsignedShortArray,
value: ::std::os::raw::c_ushort,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spUnsignedShortArray_pop(self_: *mut spUnsignedShortArray) -> ::std::os::raw::c_ushort;
}
extern "C" {
pub fn spUnsignedShortArray_peek(self_: *mut spUnsignedShortArray) -> ::std::os::raw::c_ushort;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spArrayFloatArray {
pub size: ::std::os::raw::c_int,
pub capacity: ::std::os::raw::c_int,
pub items: *mut *mut spFloatArray,
}
#[test]
fn bindgen_test_layout_spArrayFloatArray() {
assert_eq!(
::std::mem::size_of::<spArrayFloatArray>(),
16usize,
concat!("Size of: ", stringify!(spArrayFloatArray))
);
assert_eq!(
::std::mem::align_of::<spArrayFloatArray>(),
8usize,
concat!("Alignment of ", stringify!(spArrayFloatArray))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spArrayFloatArray>())).size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spArrayFloatArray),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spArrayFloatArray>())).capacity as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spArrayFloatArray),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spArrayFloatArray>())).items as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spArrayFloatArray),
"::",
stringify!(items)
)
);
}
extern "C" {
pub fn spArrayFloatArray_create(
initialCapacity: ::std::os::raw::c_int,
) -> *mut spArrayFloatArray;
}
extern "C" {
pub fn spArrayFloatArray_dispose(self_: *mut spArrayFloatArray);
}
extern "C" {
pub fn spArrayFloatArray_clear(self_: *mut spArrayFloatArray);
}
extern "C" {
pub fn spArrayFloatArray_setSize(
self_: *mut spArrayFloatArray,
newSize: ::std::os::raw::c_int,
) -> *mut spArrayFloatArray;
}
extern "C" {
pub fn spArrayFloatArray_ensureCapacity(
self_: *mut spArrayFloatArray,
newCapacity: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spArrayFloatArray_add(self_: *mut spArrayFloatArray, value: *mut spFloatArray);
}
extern "C" {
pub fn spArrayFloatArray_addAll(self_: *mut spArrayFloatArray, other: *mut spArrayFloatArray);
}
extern "C" {
pub fn spArrayFloatArray_addAllValues(
self_: *mut spArrayFloatArray,
values: *mut *mut spFloatArray,
offset: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spArrayFloatArray_removeAt(self_: *mut spArrayFloatArray, index: ::std::os::raw::c_int);
}
extern "C" {
pub fn spArrayFloatArray_contains(
self_: *mut spArrayFloatArray,
value: *mut spFloatArray,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spArrayFloatArray_pop(self_: *mut spArrayFloatArray) -> *mut spFloatArray;
}
extern "C" {
pub fn spArrayFloatArray_peek(self_: *mut spArrayFloatArray) -> *mut spFloatArray;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spArrayShortArray {
pub size: ::std::os::raw::c_int,
pub capacity: ::std::os::raw::c_int,
pub items: *mut *mut spShortArray,
}
#[test]
fn bindgen_test_layout_spArrayShortArray() {
assert_eq!(
::std::mem::size_of::<spArrayShortArray>(),
16usize,
concat!("Size of: ", stringify!(spArrayShortArray))
);
assert_eq!(
::std::mem::align_of::<spArrayShortArray>(),
8usize,
concat!("Alignment of ", stringify!(spArrayShortArray))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spArrayShortArray>())).size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spArrayShortArray),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spArrayShortArray>())).capacity as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spArrayShortArray),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spArrayShortArray>())).items as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spArrayShortArray),
"::",
stringify!(items)
)
);
}
extern "C" {
pub fn spArrayShortArray_create(
initialCapacity: ::std::os::raw::c_int,
) -> *mut spArrayShortArray;
}
extern "C" {
pub fn spArrayShortArray_dispose(self_: *mut spArrayShortArray);
}
extern "C" {
pub fn spArrayShortArray_clear(self_: *mut spArrayShortArray);
}
extern "C" {
pub fn spArrayShortArray_setSize(
self_: *mut spArrayShortArray,
newSize: ::std::os::raw::c_int,
) -> *mut spArrayShortArray;
}
extern "C" {
pub fn spArrayShortArray_ensureCapacity(
self_: *mut spArrayShortArray,
newCapacity: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spArrayShortArray_add(self_: *mut spArrayShortArray, value: *mut spShortArray);
}
extern "C" {
pub fn spArrayShortArray_addAll(self_: *mut spArrayShortArray, other: *mut spArrayShortArray);
}
extern "C" {
pub fn spArrayShortArray_addAllValues(
self_: *mut spArrayShortArray,
values: *mut *mut spShortArray,
offset: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spArrayShortArray_removeAt(self_: *mut spArrayShortArray, index: ::std::os::raw::c_int);
}
extern "C" {
pub fn spArrayShortArray_contains(
self_: *mut spArrayShortArray,
value: *mut spShortArray,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spArrayShortArray_pop(self_: *mut spArrayShortArray) -> *mut spShortArray;
}
extern "C" {
pub fn spArrayShortArray_peek(self_: *mut spArrayShortArray) -> *mut spShortArray;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spBoneDataArray {
pub size: ::std::os::raw::c_int,
pub capacity: ::std::os::raw::c_int,
pub items: *mut *mut spBoneData,
}
#[test]
fn bindgen_test_layout_spBoneDataArray() {
assert_eq!(
::std::mem::size_of::<spBoneDataArray>(),
16usize,
concat!("Size of: ", stringify!(spBoneDataArray))
);
assert_eq!(
::std::mem::align_of::<spBoneDataArray>(),
8usize,
concat!("Alignment of ", stringify!(spBoneDataArray))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoneDataArray>())).size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spBoneDataArray),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoneDataArray>())).capacity as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spBoneDataArray),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoneDataArray>())).items as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spBoneDataArray),
"::",
stringify!(items)
)
);
}
extern "C" {
pub fn spBoneDataArray_create(initialCapacity: ::std::os::raw::c_int) -> *mut spBoneDataArray;
}
extern "C" {
pub fn spBoneDataArray_dispose(self_: *mut spBoneDataArray);
}
extern "C" {
pub fn spBoneDataArray_clear(self_: *mut spBoneDataArray);
}
extern "C" {
pub fn spBoneDataArray_setSize(
self_: *mut spBoneDataArray,
newSize: ::std::os::raw::c_int,
) -> *mut spBoneDataArray;
}
extern "C" {
pub fn spBoneDataArray_ensureCapacity(
self_: *mut spBoneDataArray,
newCapacity: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spBoneDataArray_add(self_: *mut spBoneDataArray, value: *mut spBoneData);
}
extern "C" {
pub fn spBoneDataArray_addAll(self_: *mut spBoneDataArray, other: *mut spBoneDataArray);
}
extern "C" {
pub fn spBoneDataArray_addAllValues(
self_: *mut spBoneDataArray,
values: *mut *mut spBoneData,
offset: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spBoneDataArray_removeAt(self_: *mut spBoneDataArray, index: ::std::os::raw::c_int);
}
extern "C" {
pub fn spBoneDataArray_contains(
self_: *mut spBoneDataArray,
value: *mut spBoneData,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spBoneDataArray_pop(self_: *mut spBoneDataArray) -> *mut spBoneData;
}
extern "C" {
pub fn spBoneDataArray_peek(self_: *mut spBoneDataArray) -> *mut spBoneData;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spIkConstraintDataArray {
pub size: ::std::os::raw::c_int,
pub capacity: ::std::os::raw::c_int,
pub items: *mut *mut spIkConstraintData,
}
#[test]
fn bindgen_test_layout_spIkConstraintDataArray() {
assert_eq!(
::std::mem::size_of::<spIkConstraintDataArray>(),
16usize,
concat!("Size of: ", stringify!(spIkConstraintDataArray))
);
assert_eq!(
::std::mem::align_of::<spIkConstraintDataArray>(),
8usize,
concat!("Alignment of ", stringify!(spIkConstraintDataArray))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraintDataArray>())).size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintDataArray),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spIkConstraintDataArray>())).capacity as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintDataArray),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraintDataArray>())).items as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraintDataArray),
"::",
stringify!(items)
)
);
}
extern "C" {
pub fn spIkConstraintDataArray_create(
initialCapacity: ::std::os::raw::c_int,
) -> *mut spIkConstraintDataArray;
}
extern "C" {
pub fn spIkConstraintDataArray_dispose(self_: *mut spIkConstraintDataArray);
}
extern "C" {
pub fn spIkConstraintDataArray_clear(self_: *mut spIkConstraintDataArray);
}
extern "C" {
pub fn spIkConstraintDataArray_setSize(
self_: *mut spIkConstraintDataArray,
newSize: ::std::os::raw::c_int,
) -> *mut spIkConstraintDataArray;
}
extern "C" {
pub fn spIkConstraintDataArray_ensureCapacity(
self_: *mut spIkConstraintDataArray,
newCapacity: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spIkConstraintDataArray_add(
self_: *mut spIkConstraintDataArray,
value: *mut spIkConstraintData,
);
}
extern "C" {
pub fn spIkConstraintDataArray_addAll(
self_: *mut spIkConstraintDataArray,
other: *mut spIkConstraintDataArray,
);
}
extern "C" {
pub fn spIkConstraintDataArray_addAllValues(
self_: *mut spIkConstraintDataArray,
values: *mut *mut spIkConstraintData,
offset: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spIkConstraintDataArray_removeAt(
self_: *mut spIkConstraintDataArray,
index: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spIkConstraintDataArray_contains(
self_: *mut spIkConstraintDataArray,
value: *mut spIkConstraintData,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spIkConstraintDataArray_pop(
self_: *mut spIkConstraintDataArray,
) -> *mut spIkConstraintData;
}
extern "C" {
pub fn spIkConstraintDataArray_peek(
self_: *mut spIkConstraintDataArray,
) -> *mut spIkConstraintData;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spTransformConstraintDataArray {
pub size: ::std::os::raw::c_int,
pub capacity: ::std::os::raw::c_int,
pub items: *mut *mut spTransformConstraintData,
}
#[test]
fn bindgen_test_layout_spTransformConstraintDataArray() {
assert_eq!(
::std::mem::size_of::<spTransformConstraintDataArray>(),
16usize,
concat!("Size of: ", stringify!(spTransformConstraintDataArray))
);
assert_eq!(
::std::mem::align_of::<spTransformConstraintDataArray>(),
8usize,
concat!("Alignment of ", stringify!(spTransformConstraintDataArray))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintDataArray>())).size as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintDataArray),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintDataArray>())).capacity as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintDataArray),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraintDataArray>())).items as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraintDataArray),
"::",
stringify!(items)
)
);
}
extern "C" {
pub fn spTransformConstraintDataArray_create(
initialCapacity: ::std::os::raw::c_int,
) -> *mut spTransformConstraintDataArray;
}
extern "C" {
pub fn spTransformConstraintDataArray_dispose(self_: *mut spTransformConstraintDataArray);
}
extern "C" {
pub fn spTransformConstraintDataArray_clear(self_: *mut spTransformConstraintDataArray);
}
extern "C" {
pub fn spTransformConstraintDataArray_setSize(
self_: *mut spTransformConstraintDataArray,
newSize: ::std::os::raw::c_int,
) -> *mut spTransformConstraintDataArray;
}
extern "C" {
pub fn spTransformConstraintDataArray_ensureCapacity(
self_: *mut spTransformConstraintDataArray,
newCapacity: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spTransformConstraintDataArray_add(
self_: *mut spTransformConstraintDataArray,
value: *mut spTransformConstraintData,
);
}
extern "C" {
pub fn spTransformConstraintDataArray_addAll(
self_: *mut spTransformConstraintDataArray,
other: *mut spTransformConstraintDataArray,
);
}
extern "C" {
pub fn spTransformConstraintDataArray_addAllValues(
self_: *mut spTransformConstraintDataArray,
values: *mut *mut spTransformConstraintData,
offset: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spTransformConstraintDataArray_removeAt(
self_: *mut spTransformConstraintDataArray,
index: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spTransformConstraintDataArray_contains(
self_: *mut spTransformConstraintDataArray,
value: *mut spTransformConstraintData,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spTransformConstraintDataArray_pop(
self_: *mut spTransformConstraintDataArray,
) -> *mut spTransformConstraintData;
}
extern "C" {
pub fn spTransformConstraintDataArray_peek(
self_: *mut spTransformConstraintDataArray,
) -> *mut spTransformConstraintData;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spPathConstraintDataArray {
pub size: ::std::os::raw::c_int,
pub capacity: ::std::os::raw::c_int,
pub items: *mut *mut spPathConstraintData,
}
#[test]
fn bindgen_test_layout_spPathConstraintDataArray() {
assert_eq!(
::std::mem::size_of::<spPathConstraintDataArray>(),
16usize,
concat!("Size of: ", stringify!(spPathConstraintDataArray))
);
assert_eq!(
::std::mem::align_of::<spPathConstraintDataArray>(),
8usize,
concat!("Alignment of ", stringify!(spPathConstraintDataArray))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraintDataArray>())).size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintDataArray),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spPathConstraintDataArray>())).capacity as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintDataArray),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraintDataArray>())).items as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraintDataArray),
"::",
stringify!(items)
)
);
}
extern "C" {
pub fn spPathConstraintDataArray_create(
initialCapacity: ::std::os::raw::c_int,
) -> *mut spPathConstraintDataArray;
}
extern "C" {
pub fn spPathConstraintDataArray_dispose(self_: *mut spPathConstraintDataArray);
}
extern "C" {
pub fn spPathConstraintDataArray_clear(self_: *mut spPathConstraintDataArray);
}
extern "C" {
pub fn spPathConstraintDataArray_setSize(
self_: *mut spPathConstraintDataArray,
newSize: ::std::os::raw::c_int,
) -> *mut spPathConstraintDataArray;
}
extern "C" {
pub fn spPathConstraintDataArray_ensureCapacity(
self_: *mut spPathConstraintDataArray,
newCapacity: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spPathConstraintDataArray_add(
self_: *mut spPathConstraintDataArray,
value: *mut spPathConstraintData,
);
}
extern "C" {
pub fn spPathConstraintDataArray_addAll(
self_: *mut spPathConstraintDataArray,
other: *mut spPathConstraintDataArray,
);
}
extern "C" {
pub fn spPathConstraintDataArray_addAllValues(
self_: *mut spPathConstraintDataArray,
values: *mut *mut spPathConstraintData,
offset: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spPathConstraintDataArray_removeAt(
self_: *mut spPathConstraintDataArray,
index: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spPathConstraintDataArray_contains(
self_: *mut spPathConstraintDataArray,
value: *mut spPathConstraintData,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spPathConstraintDataArray_pop(
self_: *mut spPathConstraintDataArray,
) -> *mut spPathConstraintData;
}
extern "C" {
pub fn spPathConstraintDataArray_peek(
self_: *mut spPathConstraintDataArray,
) -> *mut spPathConstraintData;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spSkin {
pub name: *const ::std::os::raw::c_char,
pub bones: *mut spBoneDataArray,
pub ikConstraints: *mut spIkConstraintDataArray,
pub transformConstraints: *mut spTransformConstraintDataArray,
pub pathConstraints: *mut spPathConstraintDataArray,
}
#[test]
fn bindgen_test_layout_spSkin() {
assert_eq!(
::std::mem::size_of::<spSkin>(),
40usize,
concat!("Size of: ", stringify!(spSkin))
);
assert_eq!(
::std::mem::align_of::<spSkin>(),
8usize,
concat!("Alignment of ", stringify!(spSkin))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkin>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spSkin),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkin>())).bones as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spSkin),
"::",
stringify!(bones)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkin>())).ikConstraints as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spSkin),
"::",
stringify!(ikConstraints)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkin>())).transformConstraints as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spSkin),
"::",
stringify!(transformConstraints)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkin>())).pathConstraints as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spSkin),
"::",
stringify!(pathConstraints)
)
);
}
pub type spSkinEntry = _Entry;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _Entry {
pub slotIndex: ::std::os::raw::c_int,
pub name: *const ::std::os::raw::c_char,
pub attachment: *mut spAttachment,
pub next: *mut _Entry,
}
#[test]
fn bindgen_test_layout__Entry() {
assert_eq!(
::std::mem::size_of::<_Entry>(),
32usize,
concat!("Size of: ", stringify!(_Entry))
);
assert_eq!(
::std::mem::align_of::<_Entry>(),
8usize,
concat!("Alignment of ", stringify!(_Entry))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_Entry>())).slotIndex as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_Entry),
"::",
stringify!(slotIndex)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_Entry>())).name as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_Entry),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_Entry>())).attachment as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_Entry),
"::",
stringify!(attachment)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_Entry>())).next as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_Entry),
"::",
stringify!(next)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _SkinHashTableEntry {
pub entry: *mut _Entry,
pub next: *mut _SkinHashTableEntry,
}
#[test]
fn bindgen_test_layout__SkinHashTableEntry() {
assert_eq!(
::std::mem::size_of::<_SkinHashTableEntry>(),
16usize,
concat!("Size of: ", stringify!(_SkinHashTableEntry))
);
assert_eq!(
::std::mem::align_of::<_SkinHashTableEntry>(),
8usize,
concat!("Alignment of ", stringify!(_SkinHashTableEntry))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_SkinHashTableEntry>())).entry as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_SkinHashTableEntry),
"::",
stringify!(entry)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_SkinHashTableEntry>())).next as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_SkinHashTableEntry),
"::",
stringify!(next)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _spSkin {
pub super_: spSkin,
pub entries: *mut _Entry,
pub entriesHashTable: [*mut _SkinHashTableEntry; 100usize],
}
#[test]
fn bindgen_test_layout__spSkin() {
assert_eq!(
::std::mem::size_of::<_spSkin>(),
848usize,
concat!("Size of: ", stringify!(_spSkin))
);
assert_eq!(
::std::mem::align_of::<_spSkin>(),
8usize,
concat!("Alignment of ", stringify!(_spSkin))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_spSkin>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_spSkin),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_spSkin>())).entries as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_spSkin),
"::",
stringify!(entries)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_spSkin>())).entriesHashTable as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_spSkin),
"::",
stringify!(entriesHashTable)
)
);
}
extern "C" {
pub fn spSkin_create(name: *const ::std::os::raw::c_char) -> *mut spSkin;
}
extern "C" {
pub fn spSkin_dispose(self_: *mut spSkin);
}
extern "C" {
pub fn spSkin_setAttachment(
self_: *mut spSkin,
slotIndex: ::std::os::raw::c_int,
name: *const ::std::os::raw::c_char,
attachment: *mut spAttachment,
);
}
extern "C" {
pub fn spSkin_getAttachment(
self_: *const spSkin,
slotIndex: ::std::os::raw::c_int,
name: *const ::std::os::raw::c_char,
) -> *mut spAttachment;
}
extern "C" {
pub fn spSkin_getAttachmentName(
self_: *const spSkin,
slotIndex: ::std::os::raw::c_int,
attachmentIndex: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = " Attach each attachment in this skin if the corresponding attachment in oldSkin is currently attached."]
pub fn spSkin_attachAll(
self_: *const spSkin,
skeleton: *mut spSkeleton,
oldspSkin: *const spSkin,
);
}
extern "C" {
#[doc = " Adds all attachments, bones, and constraints from the specified skin to this skin."]
pub fn spSkin_addSkin(self_: *mut spSkin, other: *const spSkin);
}
extern "C" {
#[doc = " Adds all attachments, bones, and constraints from the specified skin to this skin. Attachments are deep copied."]
pub fn spSkin_copySkin(self_: *mut spSkin, other: *const spSkin);
}
extern "C" {
#[doc = " Returns all attachments in this skin."]
pub fn spSkin_getAttachments(self_: *const spSkin) -> *mut spSkinEntry;
}
extern "C" {
#[doc = " Clears all attachments, bones, and constraints."]
pub fn spSkin_clear(self_: *mut spSkin);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spSkeletonData {
pub version: *const ::std::os::raw::c_char,
pub hash: *const ::std::os::raw::c_char,
pub x: f32,
pub y: f32,
pub width: f32,
pub height: f32,
pub stringsCount: ::std::os::raw::c_int,
pub strings: *mut *mut ::std::os::raw::c_char,
pub bonesCount: ::std::os::raw::c_int,
pub bones: *mut *mut spBoneData,
pub slotsCount: ::std::os::raw::c_int,
pub slots: *mut *mut spSlotData,
pub skinsCount: ::std::os::raw::c_int,
pub skins: *mut *mut spSkin,
pub defaultSkin: *mut spSkin,
pub eventsCount: ::std::os::raw::c_int,
pub events: *mut *mut spEventData,
pub animationsCount: ::std::os::raw::c_int,
pub animations: *mut *mut spAnimation,
pub ikConstraintsCount: ::std::os::raw::c_int,
pub ikConstraints: *mut *mut spIkConstraintData,
pub transformConstraintsCount: ::std::os::raw::c_int,
pub transformConstraints: *mut *mut spTransformConstraintData,
pub pathConstraintsCount: ::std::os::raw::c_int,
pub pathConstraints: *mut *mut spPathConstraintData,
}
#[test]
fn bindgen_test_layout_spSkeletonData() {
assert_eq!(
::std::mem::size_of::<spSkeletonData>(),
184usize,
concat!("Size of: ", stringify!(spSkeletonData))
);
assert_eq!(
::std::mem::align_of::<spSkeletonData>(),
8usize,
concat!("Alignment of ", stringify!(spSkeletonData))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).version as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(version)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).hash as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).x as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).y as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).width as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).height as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).stringsCount as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(stringsCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).strings as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(strings)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).bonesCount as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(bonesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).bones as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(bones)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).slotsCount as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(slotsCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).slots as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(slots)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).skinsCount as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(skinsCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).skins as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(skins)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).defaultSkin as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(defaultSkin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).eventsCount as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(eventsCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).events as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(events)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).animationsCount as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(animationsCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).animations as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(animations)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spSkeletonData>())).ikConstraintsCount as *const _ as usize
},
136usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(ikConstraintsCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).ikConstraints as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(ikConstraints)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spSkeletonData>())).transformConstraintsCount as *const _
as usize
},
152usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(transformConstraintsCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spSkeletonData>())).transformConstraints as *const _ as usize
},
160usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(transformConstraints)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spSkeletonData>())).pathConstraintsCount as *const _ as usize
},
168usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(pathConstraintsCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonData>())).pathConstraints as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonData),
"::",
stringify!(pathConstraints)
)
);
}
extern "C" {
pub fn spSkeletonData_create() -> *mut spSkeletonData;
}
extern "C" {
pub fn spSkeletonData_dispose(self_: *mut spSkeletonData);
}
extern "C" {
pub fn spSkeletonData_findBone(
self_: *const spSkeletonData,
boneName: *const ::std::os::raw::c_char,
) -> *mut spBoneData;
}
extern "C" {
pub fn spSkeletonData_findBoneIndex(
self_: *const spSkeletonData,
boneName: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spSkeletonData_findSlot(
self_: *const spSkeletonData,
slotName: *const ::std::os::raw::c_char,
) -> *mut spSlotData;
}
extern "C" {
pub fn spSkeletonData_findSlotIndex(
self_: *const spSkeletonData,
slotName: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spSkeletonData_findSkin(
self_: *const spSkeletonData,
skinName: *const ::std::os::raw::c_char,
) -> *mut spSkin;
}
extern "C" {
pub fn spSkeletonData_findEvent(
self_: *const spSkeletonData,
eventName: *const ::std::os::raw::c_char,
) -> *mut spEventData;
}
extern "C" {
pub fn spSkeletonData_findAnimation(
self_: *const spSkeletonData,
animationName: *const ::std::os::raw::c_char,
) -> *mut spAnimation;
}
extern "C" {
pub fn spSkeletonData_findIkConstraint(
self_: *const spSkeletonData,
constraintName: *const ::std::os::raw::c_char,
) -> *mut spIkConstraintData;
}
extern "C" {
pub fn spSkeletonData_findTransformConstraint(
self_: *const spSkeletonData,
constraintName: *const ::std::os::raw::c_char,
) -> *mut spTransformConstraintData;
}
extern "C" {
pub fn spSkeletonData_findPathConstraint(
self_: *const spSkeletonData,
constraintName: *const ::std::os::raw::c_char,
) -> *mut spPathConstraintData;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spAnimationStateData {
pub skeletonData: *mut spSkeletonData,
pub defaultMix: f32,
pub entries: *const ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_spAnimationStateData() {
assert_eq!(
::std::mem::size_of::<spAnimationStateData>(),
24usize,
concat!("Size of: ", stringify!(spAnimationStateData))
);
assert_eq!(
::std::mem::align_of::<spAnimationStateData>(),
8usize,
concat!("Alignment of ", stringify!(spAnimationStateData))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spAnimationStateData>())).skeletonData as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(spAnimationStateData),
"::",
stringify!(skeletonData)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAnimationStateData>())).defaultMix as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spAnimationStateData),
"::",
stringify!(defaultMix)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAnimationStateData>())).entries as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spAnimationStateData),
"::",
stringify!(entries)
)
);
}
extern "C" {
pub fn spAnimationStateData_create(
skeletonData: *mut spSkeletonData,
) -> *mut spAnimationStateData;
}
extern "C" {
pub fn spAnimationStateData_dispose(self_: *mut spAnimationStateData);
}
extern "C" {
pub fn spAnimationStateData_setMixByName(
self_: *mut spAnimationStateData,
fromName: *const ::std::os::raw::c_char,
toName: *const ::std::os::raw::c_char,
duration: f32,
);
}
extern "C" {
pub fn spAnimationStateData_setMix(
self_: *mut spAnimationStateData,
from: *mut spAnimation,
to: *mut spAnimation,
duration: f32,
);
}
extern "C" {
pub fn spAnimationStateData_getMix(
self_: *mut spAnimationStateData,
from: *mut spAnimation,
to: *mut spAnimation,
) -> f32;
}
pub const spEventType_SP_ANIMATION_START: spEventType = 0;
pub const spEventType_SP_ANIMATION_INTERRUPT: spEventType = 1;
pub const spEventType_SP_ANIMATION_END: spEventType = 2;
pub const spEventType_SP_ANIMATION_COMPLETE: spEventType = 3;
pub const spEventType_SP_ANIMATION_DISPOSE: spEventType = 4;
pub const spEventType_SP_ANIMATION_EVENT: spEventType = 5;
pub type spEventType = u32;
pub type spAnimationStateListener = ::std::option::Option<
unsafe extern "C" fn(
state: *mut spAnimationState,
type_: spEventType,
entry: *mut spTrackEntry,
event: *mut spEvent,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spTrackEntryArray {
pub size: ::std::os::raw::c_int,
pub capacity: ::std::os::raw::c_int,
pub items: *mut *mut spTrackEntry,
}
#[test]
fn bindgen_test_layout_spTrackEntryArray() {
assert_eq!(
::std::mem::size_of::<spTrackEntryArray>(),
16usize,
concat!("Size of: ", stringify!(spTrackEntryArray))
);
assert_eq!(
::std::mem::align_of::<spTrackEntryArray>(),
8usize,
concat!("Alignment of ", stringify!(spTrackEntryArray))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntryArray>())).size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntryArray),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntryArray>())).capacity as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntryArray),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntryArray>())).items as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntryArray),
"::",
stringify!(items)
)
);
}
extern "C" {
pub fn spTrackEntryArray_create(
initialCapacity: ::std::os::raw::c_int,
) -> *mut spTrackEntryArray;
}
extern "C" {
pub fn spTrackEntryArray_dispose(self_: *mut spTrackEntryArray);
}
extern "C" {
pub fn spTrackEntryArray_clear(self_: *mut spTrackEntryArray);
}
extern "C" {
pub fn spTrackEntryArray_setSize(
self_: *mut spTrackEntryArray,
newSize: ::std::os::raw::c_int,
) -> *mut spTrackEntryArray;
}
extern "C" {
pub fn spTrackEntryArray_ensureCapacity(
self_: *mut spTrackEntryArray,
newCapacity: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spTrackEntryArray_add(self_: *mut spTrackEntryArray, value: *mut spTrackEntry);
}
extern "C" {
pub fn spTrackEntryArray_addAll(self_: *mut spTrackEntryArray, other: *mut spTrackEntryArray);
}
extern "C" {
pub fn spTrackEntryArray_addAllValues(
self_: *mut spTrackEntryArray,
values: *mut *mut spTrackEntry,
offset: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spTrackEntryArray_removeAt(self_: *mut spTrackEntryArray, index: ::std::os::raw::c_int);
}
extern "C" {
pub fn spTrackEntryArray_contains(
self_: *mut spTrackEntryArray,
value: *mut spTrackEntry,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spTrackEntryArray_pop(self_: *mut spTrackEntryArray) -> *mut spTrackEntry;
}
extern "C" {
pub fn spTrackEntryArray_peek(self_: *mut spTrackEntryArray) -> *mut spTrackEntry;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spTrackEntry {
pub animation: *mut spAnimation,
pub next: *mut spTrackEntry,
pub mixingFrom: *mut spTrackEntry,
pub mixingTo: *mut spTrackEntry,
pub listener: spAnimationStateListener,
pub trackIndex: ::std::os::raw::c_int,
pub loop_: ::std::os::raw::c_int,
pub holdPrevious: ::std::os::raw::c_int,
pub eventThreshold: f32,
pub attachmentThreshold: f32,
pub drawOrderThreshold: f32,
pub animationStart: f32,
pub animationEnd: f32,
pub animationLast: f32,
pub nextAnimationLast: f32,
pub delay: f32,
pub trackTime: f32,
pub trackLast: f32,
pub nextTrackLast: f32,
pub trackEnd: f32,
pub timeScale: f32,
pub alpha: f32,
pub mixTime: f32,
pub mixDuration: f32,
pub interruptAlpha: f32,
pub totalAlpha: f32,
pub mixBlend: spMixBlend,
pub timelineMode: *mut spIntArray,
pub timelineHoldMix: *mut spTrackEntryArray,
pub timelinesRotation: *mut f32,
pub timelinesRotationCount: ::std::os::raw::c_int,
pub rendererObject: *mut ::std::os::raw::c_void,
pub userData: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_spTrackEntry() {
assert_eq!(
::std::mem::size_of::<spTrackEntry>(),
176usize,
concat!("Size of: ", stringify!(spTrackEntry))
);
assert_eq!(
::std::mem::align_of::<spTrackEntry>(),
8usize,
concat!("Alignment of ", stringify!(spTrackEntry))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).animation as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(animation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).next as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).mixingFrom as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(mixingFrom)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).mixingTo as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(mixingTo)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).listener as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(listener)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).trackIndex as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(trackIndex)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).loop_ as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(loop_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).holdPrevious as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(holdPrevious)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).eventThreshold as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(eventThreshold)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTrackEntry>())).attachmentThreshold as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(attachmentThreshold)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).drawOrderThreshold as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(drawOrderThreshold)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).animationStart as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(animationStart)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).animationEnd as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(animationEnd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).animationLast as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(animationLast)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).nextAnimationLast as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(nextAnimationLast)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).delay as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(delay)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).trackTime as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(trackTime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).trackLast as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(trackLast)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).nextTrackLast as *const _ as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(nextTrackLast)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).trackEnd as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(trackEnd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).timeScale as *const _ as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(timeScale)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).alpha as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(alpha)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).mixTime as *const _ as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(mixTime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).mixDuration as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(mixDuration)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).interruptAlpha as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(interruptAlpha)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).totalAlpha as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(totalAlpha)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).mixBlend as *const _ as usize },
124usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(mixBlend)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).timelineMode as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(timelineMode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).timelineHoldMix as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(timelineHoldMix)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).timelinesRotation as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(timelinesRotation)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTrackEntry>())).timelinesRotationCount as *const _ as usize
},
152usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(timelinesRotationCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).rendererObject as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(rendererObject)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTrackEntry>())).userData as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(spTrackEntry),
"::",
stringify!(userData)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spAnimationState {
pub data: *mut spAnimationStateData,
pub tracksCount: ::std::os::raw::c_int,
pub tracks: *mut *mut spTrackEntry,
pub listener: spAnimationStateListener,
pub timeScale: f32,
pub rendererObject: *mut ::std::os::raw::c_void,
pub userData: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_spAnimationState() {
assert_eq!(
::std::mem::size_of::<spAnimationState>(),
56usize,
concat!("Size of: ", stringify!(spAnimationState))
);
assert_eq!(
::std::mem::align_of::<spAnimationState>(),
8usize,
concat!("Alignment of ", stringify!(spAnimationState))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAnimationState>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spAnimationState),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAnimationState>())).tracksCount as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spAnimationState),
"::",
stringify!(tracksCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAnimationState>())).tracks as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spAnimationState),
"::",
stringify!(tracks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAnimationState>())).listener as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spAnimationState),
"::",
stringify!(listener)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAnimationState>())).timeScale as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spAnimationState),
"::",
stringify!(timeScale)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAnimationState>())).rendererObject as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spAnimationState),
"::",
stringify!(rendererObject)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAnimationState>())).userData as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spAnimationState),
"::",
stringify!(userData)
)
);
}
extern "C" {
pub fn spAnimationState_create(data: *mut spAnimationStateData) -> *mut spAnimationState;
}
extern "C" {
pub fn spAnimationState_dispose(self_: *mut spAnimationState);
}
extern "C" {
pub fn spAnimationState_update(self_: *mut spAnimationState, delta: f32);
}
extern "C" {
#[doc = "bool"]
pub fn spAnimationState_apply(
self_: *mut spAnimationState,
skeleton: *mut spSkeleton,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spAnimationState_clearTracks(self_: *mut spAnimationState);
}
extern "C" {
pub fn spAnimationState_clearTrack(
self_: *mut spAnimationState,
trackIndex: ::std::os::raw::c_int,
);
}
extern "C" {
#[doc = " Set the current animation. Any queued animations are cleared."]
pub fn spAnimationState_setAnimationByName(
self_: *mut spAnimationState,
trackIndex: ::std::os::raw::c_int,
animationName: *const ::std::os::raw::c_char,
loop_: ::std::os::raw::c_int,
) -> *mut spTrackEntry;
}
extern "C" {
pub fn spAnimationState_setAnimation(
self_: *mut spAnimationState,
trackIndex: ::std::os::raw::c_int,
animation: *mut spAnimation,
loop_: ::std::os::raw::c_int,
) -> *mut spTrackEntry;
}
extern "C" {
#[doc = " Adds an animation to be played delay seconds after the current or last queued animation, taking into account any mix"]
#[doc = " duration."]
pub fn spAnimationState_addAnimationByName(
self_: *mut spAnimationState,
trackIndex: ::std::os::raw::c_int,
animationName: *const ::std::os::raw::c_char,
loop_: ::std::os::raw::c_int,
delay: f32,
) -> *mut spTrackEntry;
}
extern "C" {
pub fn spAnimationState_addAnimation(
self_: *mut spAnimationState,
trackIndex: ::std::os::raw::c_int,
animation: *mut spAnimation,
loop_: ::std::os::raw::c_int,
delay: f32,
) -> *mut spTrackEntry;
}
extern "C" {
pub fn spAnimationState_setEmptyAnimation(
self_: *mut spAnimationState,
trackIndex: ::std::os::raw::c_int,
mixDuration: f32,
) -> *mut spTrackEntry;
}
extern "C" {
pub fn spAnimationState_addEmptyAnimation(
self_: *mut spAnimationState,
trackIndex: ::std::os::raw::c_int,
mixDuration: f32,
delay: f32,
) -> *mut spTrackEntry;
}
extern "C" {
pub fn spAnimationState_setEmptyAnimations(self_: *mut spAnimationState, mixDuration: f32);
}
extern "C" {
pub fn spAnimationState_getCurrent(
self_: *mut spAnimationState,
trackIndex: ::std::os::raw::c_int,
) -> *mut spTrackEntry;
}
extern "C" {
pub fn spAnimationState_clearListenerNotifications(self_: *mut spAnimationState);
}
extern "C" {
pub fn spTrackEntry_getAnimationTime(entry: *mut spTrackEntry) -> f32;
}
extern "C" {
#[doc = " Use this to dispose static memory before your app exits to appease your memory leak detector"]
pub fn spAnimationState_disposeStatics();
}
pub const spAtlasFormat_SP_ATLAS_UNKNOWN_FORMAT: spAtlasFormat = 0;
pub const spAtlasFormat_SP_ATLAS_ALPHA: spAtlasFormat = 1;
pub const spAtlasFormat_SP_ATLAS_INTENSITY: spAtlasFormat = 2;
pub const spAtlasFormat_SP_ATLAS_LUMINANCE_ALPHA: spAtlasFormat = 3;
pub const spAtlasFormat_SP_ATLAS_RGB565: spAtlasFormat = 4;
pub const spAtlasFormat_SP_ATLAS_RGBA4444: spAtlasFormat = 5;
pub const spAtlasFormat_SP_ATLAS_RGB888: spAtlasFormat = 6;
pub const spAtlasFormat_SP_ATLAS_RGBA8888: spAtlasFormat = 7;
pub type spAtlasFormat = u32;
pub const spAtlasFilter_SP_ATLAS_UNKNOWN_FILTER: spAtlasFilter = 0;
pub const spAtlasFilter_SP_ATLAS_NEAREST: spAtlasFilter = 1;
pub const spAtlasFilter_SP_ATLAS_LINEAR: spAtlasFilter = 2;
pub const spAtlasFilter_SP_ATLAS_MIPMAP: spAtlasFilter = 3;
pub const spAtlasFilter_SP_ATLAS_MIPMAP_NEAREST_NEAREST: spAtlasFilter = 4;
pub const spAtlasFilter_SP_ATLAS_MIPMAP_LINEAR_NEAREST: spAtlasFilter = 5;
pub const spAtlasFilter_SP_ATLAS_MIPMAP_NEAREST_LINEAR: spAtlasFilter = 6;
pub const spAtlasFilter_SP_ATLAS_MIPMAP_LINEAR_LINEAR: spAtlasFilter = 7;
pub type spAtlasFilter = u32;
pub const spAtlasWrap_SP_ATLAS_MIRROREDREPEAT: spAtlasWrap = 0;
pub const spAtlasWrap_SP_ATLAS_CLAMPTOEDGE: spAtlasWrap = 1;
pub const spAtlasWrap_SP_ATLAS_REPEAT: spAtlasWrap = 2;
pub type spAtlasWrap = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spAtlasPage {
pub atlas: *const spAtlas,
pub name: *const ::std::os::raw::c_char,
pub format: spAtlasFormat,
pub minFilter: spAtlasFilter,
pub magFilter: spAtlasFilter,
pub uWrap: spAtlasWrap,
pub vWrap: spAtlasWrap,
pub rendererObject: *mut ::std::os::raw::c_void,
pub width: ::std::os::raw::c_int,
pub height: ::std::os::raw::c_int,
pub next: *mut spAtlasPage,
}
#[test]
fn bindgen_test_layout_spAtlasPage() {
assert_eq!(
::std::mem::size_of::<spAtlasPage>(),
64usize,
concat!("Size of: ", stringify!(spAtlasPage))
);
assert_eq!(
::std::mem::align_of::<spAtlasPage>(),
8usize,
concat!("Alignment of ", stringify!(spAtlasPage))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasPage>())).atlas as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spAtlasPage),
"::",
stringify!(atlas)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasPage>())).name as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spAtlasPage),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasPage>())).format as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spAtlasPage),
"::",
stringify!(format)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasPage>())).minFilter as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(spAtlasPage),
"::",
stringify!(minFilter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasPage>())).magFilter as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spAtlasPage),
"::",
stringify!(magFilter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasPage>())).uWrap as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(spAtlasPage),
"::",
stringify!(uWrap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasPage>())).vWrap as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spAtlasPage),
"::",
stringify!(vWrap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasPage>())).rendererObject as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spAtlasPage),
"::",
stringify!(rendererObject)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasPage>())).width as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spAtlasPage),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasPage>())).height as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(spAtlasPage),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasPage>())).next as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(spAtlasPage),
"::",
stringify!(next)
)
);
}
extern "C" {
pub fn spAtlasPage_create(
atlas: *mut spAtlas,
name: *const ::std::os::raw::c_char,
) -> *mut spAtlasPage;
}
extern "C" {
pub fn spAtlasPage_dispose(self_: *mut spAtlasPage);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spAtlasRegion {
pub name: *const ::std::os::raw::c_char,
pub x: ::std::os::raw::c_int,
pub y: ::std::os::raw::c_int,
pub width: ::std::os::raw::c_int,
pub height: ::std::os::raw::c_int,
pub u: f32,
pub v: f32,
pub u2: f32,
pub v2: f32,
pub offsetX: ::std::os::raw::c_int,
pub offsetY: ::std::os::raw::c_int,
pub originalWidth: ::std::os::raw::c_int,
pub originalHeight: ::std::os::raw::c_int,
pub index: ::std::os::raw::c_int,
pub rotate: ::std::os::raw::c_int,
pub degrees: ::std::os::raw::c_int,
pub flip: ::std::os::raw::c_int,
pub splits: *mut ::std::os::raw::c_int,
pub pads: *mut ::std::os::raw::c_int,
pub page: *mut spAtlasPage,
pub next: *mut spAtlasRegion,
}
#[test]
fn bindgen_test_layout_spAtlasRegion() {
assert_eq!(
::std::mem::size_of::<spAtlasRegion>(),
104usize,
concat!("Size of: ", stringify!(spAtlasRegion))
);
assert_eq!(
::std::mem::align_of::<spAtlasRegion>(),
8usize,
concat!("Alignment of ", stringify!(spAtlasRegion))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).x as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).y as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).width as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).height as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).u as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).v as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).u2 as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(u2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).v2 as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(v2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).offsetX as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(offsetX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).offsetY as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(offsetY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).originalWidth as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(originalWidth)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).originalHeight as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(originalHeight)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).index as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).rotate as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(rotate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).degrees as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(degrees)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).flip as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(flip)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).splits as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(splits)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).pads as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(pads)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).page as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(page)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasRegion>())).next as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(spAtlasRegion),
"::",
stringify!(next)
)
);
}
extern "C" {
pub fn spAtlasRegion_create() -> *mut spAtlasRegion;
}
extern "C" {
pub fn spAtlasRegion_dispose(self_: *mut spAtlasRegion);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spAtlas {
pub pages: *mut spAtlasPage,
pub regions: *mut spAtlasRegion,
pub rendererObject: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_spAtlas() {
assert_eq!(
::std::mem::size_of::<spAtlas>(),
24usize,
concat!("Size of: ", stringify!(spAtlas))
);
assert_eq!(
::std::mem::align_of::<spAtlas>(),
8usize,
concat!("Alignment of ", stringify!(spAtlas))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlas>())).pages as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spAtlas),
"::",
stringify!(pages)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlas>())).regions as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spAtlas),
"::",
stringify!(regions)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlas>())).rendererObject as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spAtlas),
"::",
stringify!(rendererObject)
)
);
}
extern "C" {
pub fn spAtlas_create(
data: *const ::std::os::raw::c_char,
length: ::std::os::raw::c_int,
dir: *const ::std::os::raw::c_char,
rendererObject: *mut ::std::os::raw::c_void,
) -> *mut spAtlas;
}
extern "C" {
pub fn spAtlas_createFromFile(
path: *const ::std::os::raw::c_char,
rendererObject: *mut ::std::os::raw::c_void,
) -> *mut spAtlas;
}
extern "C" {
pub fn spAtlas_dispose(atlas: *mut spAtlas);
}
extern "C" {
pub fn spAtlas_findRegion(
self_: *const spAtlas,
name: *const ::std::os::raw::c_char,
) -> *mut spAtlasRegion;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spAttachmentLoader {
pub error1: *const ::std::os::raw::c_char,
pub error2: *const ::std::os::raw::c_char,
pub vtable: *const ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_spAttachmentLoader() {
assert_eq!(
::std::mem::size_of::<spAttachmentLoader>(),
24usize,
concat!("Size of: ", stringify!(spAttachmentLoader))
);
assert_eq!(
::std::mem::align_of::<spAttachmentLoader>(),
8usize,
concat!("Alignment of ", stringify!(spAttachmentLoader))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAttachmentLoader>())).error1 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spAttachmentLoader),
"::",
stringify!(error1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAttachmentLoader>())).error2 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spAttachmentLoader),
"::",
stringify!(error2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAttachmentLoader>())).vtable as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spAttachmentLoader),
"::",
stringify!(vtable)
)
);
}
extern "C" {
pub fn spAttachmentLoader_dispose(self_: *mut spAttachmentLoader);
}
extern "C" {
pub fn spAttachmentLoader_createAttachment(
self_: *mut spAttachmentLoader,
skin: *mut spSkin,
type_: spAttachmentType,
name: *const ::std::os::raw::c_char,
path: *const ::std::os::raw::c_char,
) -> *mut spAttachment;
}
extern "C" {
pub fn spAttachmentLoader_configureAttachment(
self_: *mut spAttachmentLoader,
attachment: *mut spAttachment,
);
}
extern "C" {
pub fn spAttachmentLoader_disposeAttachment(
self_: *mut spAttachmentLoader,
attachment: *mut spAttachment,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spAtlasAttachmentLoader {
pub super_: spAttachmentLoader,
pub atlas: *mut spAtlas,
}
#[test]
fn bindgen_test_layout_spAtlasAttachmentLoader() {
assert_eq!(
::std::mem::size_of::<spAtlasAttachmentLoader>(),
32usize,
concat!("Size of: ", stringify!(spAtlasAttachmentLoader))
);
assert_eq!(
::std::mem::align_of::<spAtlasAttachmentLoader>(),
8usize,
concat!("Alignment of ", stringify!(spAtlasAttachmentLoader))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasAttachmentLoader>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spAtlasAttachmentLoader),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spAtlasAttachmentLoader>())).atlas as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spAtlasAttachmentLoader),
"::",
stringify!(atlas)
)
);
}
extern "C" {
pub fn spAtlasAttachmentLoader_create(atlas: *mut spAtlas) -> *mut spAtlasAttachmentLoader;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spBone {
pub data: *mut spBoneData,
pub skeleton: *mut spSkeleton,
pub parent: *mut spBone,
pub childrenCount: ::std::os::raw::c_int,
pub children: *mut *mut spBone,
pub x: f32,
pub y: f32,
pub rotation: f32,
pub scaleX: f32,
pub scaleY: f32,
pub shearX: f32,
pub shearY: f32,
pub ax: f32,
pub ay: f32,
pub arotation: f32,
pub ascaleX: f32,
pub ascaleY: f32,
pub ashearX: f32,
pub ashearY: f32,
pub appliedValid: ::std::os::raw::c_int,
pub a: f32,
pub b: f32,
pub worldX: f32,
pub c: f32,
pub d: f32,
pub worldY: f32,
pub sorted: ::std::os::raw::c_int,
pub active: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spBone() {
assert_eq!(
::std::mem::size_of::<spBone>(),
136usize,
concat!("Size of: ", stringify!(spBone))
);
assert_eq!(
::std::mem::align_of::<spBone>(),
8usize,
concat!("Alignment of ", stringify!(spBone))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).skeleton as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(skeleton)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).parent as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).childrenCount as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(childrenCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).children as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(children)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).x as *const _ as usize },
40usize,
concat!("Offset of field: ", stringify!(spBone), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).y as *const _ as usize },
44usize,
concat!("Offset of field: ", stringify!(spBone), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).rotation as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(rotation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).scaleX as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(scaleX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).scaleY as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(scaleY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).shearX as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(shearX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).shearY as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(shearY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).ax as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(ax)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).ay as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(ay)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).arotation as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(arotation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).ascaleX as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(ascaleX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).ascaleY as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(ascaleY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).ashearX as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(ashearX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).ashearY as *const _ as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(ashearY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).appliedValid as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(appliedValid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).a as *const _ as usize },
100usize,
concat!("Offset of field: ", stringify!(spBone), "::", stringify!(a))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).b as *const _ as usize },
104usize,
concat!("Offset of field: ", stringify!(spBone), "::", stringify!(b))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).worldX as *const _ as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(worldX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).c as *const _ as usize },
112usize,
concat!("Offset of field: ", stringify!(spBone), "::", stringify!(c))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).d as *const _ as usize },
116usize,
concat!("Offset of field: ", stringify!(spBone), "::", stringify!(d))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).worldY as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(worldY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).sorted as *const _ as usize },
124usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(sorted)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBone>())).active as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(spBone),
"::",
stringify!(active)
)
);
}
extern "C" {
pub fn spBone_setYDown(yDown: ::std::os::raw::c_int);
}
extern "C" {
pub fn spBone_isYDown() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spBone_create(
data: *mut spBoneData,
skeleton: *mut spSkeleton,
parent: *mut spBone,
) -> *mut spBone;
}
extern "C" {
pub fn spBone_dispose(self_: *mut spBone);
}
extern "C" {
pub fn spBone_setToSetupPose(self_: *mut spBone);
}
extern "C" {
pub fn spBone_updateWorldTransform(self_: *mut spBone);
}
extern "C" {
pub fn spBone_updateWorldTransformWith(
self_: *mut spBone,
x: f32,
y: f32,
rotation: f32,
scaleX: f32,
scaleY: f32,
shearX: f32,
shearY: f32,
);
}
extern "C" {
pub fn spBone_getWorldRotationX(self_: *mut spBone) -> f32;
}
extern "C" {
pub fn spBone_getWorldRotationY(self_: *mut spBone) -> f32;
}
extern "C" {
pub fn spBone_getWorldScaleX(self_: *mut spBone) -> f32;
}
extern "C" {
pub fn spBone_getWorldScaleY(self_: *mut spBone) -> f32;
}
extern "C" {
pub fn spBone_updateAppliedTransform(self_: *mut spBone);
}
extern "C" {
pub fn spBone_worldToLocal(
self_: *mut spBone,
worldX: f32,
worldY: f32,
localX: *mut f32,
localY: *mut f32,
);
}
extern "C" {
pub fn spBone_localToWorld(
self_: *mut spBone,
localX: f32,
localY: f32,
worldX: *mut f32,
worldY: *mut f32,
);
}
extern "C" {
pub fn spBone_worldToLocalRotation(self_: *mut spBone, worldRotation: f32) -> f32;
}
extern "C" {
pub fn spBone_localToWorldRotation(self_: *mut spBone, localRotation: f32) -> f32;
}
extern "C" {
pub fn spBone_rotateWorld(self_: *mut spBone, degrees: f32);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spSlot {
pub data: *mut spSlotData,
pub bone: *mut spBone,
pub color: spColor,
pub darkColor: *mut spColor,
pub attachment: *mut spAttachment,
pub deformCapacity: ::std::os::raw::c_int,
pub deformCount: ::std::os::raw::c_int,
pub deform: *mut f32,
}
#[test]
fn bindgen_test_layout_spSlot() {
assert_eq!(
::std::mem::size_of::<spSlot>(),
64usize,
concat!("Size of: ", stringify!(spSlot))
);
assert_eq!(
::std::mem::align_of::<spSlot>(),
8usize,
concat!("Alignment of ", stringify!(spSlot))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSlot>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spSlot),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSlot>())).bone as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spSlot),
"::",
stringify!(bone)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSlot>())).color as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spSlot),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSlot>())).darkColor as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spSlot),
"::",
stringify!(darkColor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSlot>())).attachment as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spSlot),
"::",
stringify!(attachment)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSlot>())).deformCapacity as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spSlot),
"::",
stringify!(deformCapacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSlot>())).deformCount as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(spSlot),
"::",
stringify!(deformCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSlot>())).deform as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(spSlot),
"::",
stringify!(deform)
)
);
}
extern "C" {
pub fn spSlot_create(data: *mut spSlotData, bone: *mut spBone) -> *mut spSlot;
}
extern "C" {
pub fn spSlot_dispose(self_: *mut spSlot);
}
extern "C" {
pub fn spSlot_setAttachment(self_: *mut spSlot, attachment: *mut spAttachment);
}
extern "C" {
pub fn spSlot_setAttachmentTime(self_: *mut spSlot, time: f32);
}
extern "C" {
pub fn spSlot_getAttachmentTime(self_: *const spSlot) -> f32;
}
extern "C" {
pub fn spSlot_setToSetupPose(self_: *mut spSlot);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spRegionAttachment {
pub super_: spAttachment,
pub path: *const ::std::os::raw::c_char,
pub x: f32,
pub y: f32,
pub scaleX: f32,
pub scaleY: f32,
pub rotation: f32,
pub width: f32,
pub height: f32,
pub color: spColor,
pub rendererObject: *mut ::std::os::raw::c_void,
pub regionOffsetX: ::std::os::raw::c_int,
pub regionOffsetY: ::std::os::raw::c_int,
pub regionWidth: ::std::os::raw::c_int,
pub regionHeight: ::std::os::raw::c_int,
pub regionOriginalWidth: ::std::os::raw::c_int,
pub regionOriginalHeight: ::std::os::raw::c_int,
pub offset: [f32; 8usize],
pub uvs: [f32; 8usize],
}
#[test]
fn bindgen_test_layout_spRegionAttachment() {
assert_eq!(
::std::mem::size_of::<spRegionAttachment>(),
192usize,
concat!("Size of: ", stringify!(spRegionAttachment))
);
assert_eq!(
::std::mem::align_of::<spRegionAttachment>(),
8usize,
concat!("Alignment of ", stringify!(spRegionAttachment))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).path as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(path)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).x as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).y as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).scaleX as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(scaleX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).scaleY as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(scaleY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).rotation as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(rotation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).width as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).height as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).color as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spRegionAttachment>())).rendererObject as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(rendererObject)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spRegionAttachment>())).regionOffsetX as *const _ as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(regionOffsetX)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spRegionAttachment>())).regionOffsetY as *const _ as usize
},
108usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(regionOffsetY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).regionWidth as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(regionWidth)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).regionHeight as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(regionHeight)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spRegionAttachment>())).regionOriginalWidth as *const _ as usize
},
120usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(regionOriginalWidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spRegionAttachment>())).regionOriginalHeight as *const _ as usize
},
124usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(regionOriginalHeight)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).offset as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spRegionAttachment>())).uvs as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(spRegionAttachment),
"::",
stringify!(uvs)
)
);
}
extern "C" {
pub fn spRegionAttachment_create(
name: *const ::std::os::raw::c_char,
) -> *mut spRegionAttachment;
}
extern "C" {
pub fn spRegionAttachment_setUVs(
self_: *mut spRegionAttachment,
u: f32,
v: f32,
u2: f32,
v2: f32,
rotate: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spRegionAttachment_updateOffset(self_: *mut spRegionAttachment);
}
extern "C" {
pub fn spRegionAttachment_computeWorldVertices(
self_: *mut spRegionAttachment,
bone: *mut spBone,
vertices: *mut f32,
offset: ::std::os::raw::c_int,
stride: ::std::os::raw::c_int,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spVertexAttachment {
pub super_: spAttachment,
pub bonesCount: ::std::os::raw::c_int,
pub bones: *mut ::std::os::raw::c_int,
pub verticesCount: ::std::os::raw::c_int,
pub vertices: *mut f32,
pub worldVerticesLength: ::std::os::raw::c_int,
pub deformAttachment: *mut spVertexAttachment,
pub id: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spVertexAttachment() {
assert_eq!(
::std::mem::size_of::<spVertexAttachment>(),
96usize,
concat!("Size of: ", stringify!(spVertexAttachment))
);
assert_eq!(
::std::mem::align_of::<spVertexAttachment>(),
8usize,
concat!("Alignment of ", stringify!(spVertexAttachment))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spVertexAttachment>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spVertexAttachment),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spVertexAttachment>())).bonesCount as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spVertexAttachment),
"::",
stringify!(bonesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spVertexAttachment>())).bones as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spVertexAttachment),
"::",
stringify!(bones)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spVertexAttachment>())).verticesCount as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(spVertexAttachment),
"::",
stringify!(verticesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spVertexAttachment>())).vertices as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(spVertexAttachment),
"::",
stringify!(vertices)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spVertexAttachment>())).worldVerticesLength as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(spVertexAttachment),
"::",
stringify!(worldVerticesLength)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spVertexAttachment>())).deformAttachment as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(spVertexAttachment),
"::",
stringify!(deformAttachment)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spVertexAttachment>())).id as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(spVertexAttachment),
"::",
stringify!(id)
)
);
}
extern "C" {
pub fn spVertexAttachment_computeWorldVertices(
self_: *mut spVertexAttachment,
slot: *mut spSlot,
start: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
worldVertices: *mut f32,
offset: ::std::os::raw::c_int,
stride: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spVertexAttachment_copyTo(
self_: *mut spVertexAttachment,
other: *mut spVertexAttachment,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spMeshAttachment {
pub super_: spVertexAttachment,
pub rendererObject: *mut ::std::os::raw::c_void,
pub regionOffsetX: ::std::os::raw::c_int,
pub regionOffsetY: ::std::os::raw::c_int,
pub regionWidth: ::std::os::raw::c_int,
pub regionHeight: ::std::os::raw::c_int,
pub regionOriginalWidth: ::std::os::raw::c_int,
pub regionOriginalHeight: ::std::os::raw::c_int,
pub regionU: f32,
pub regionV: f32,
pub regionU2: f32,
pub regionV2: f32,
pub regionRotate: ::std::os::raw::c_int,
pub regionDegrees: ::std::os::raw::c_int,
pub path: *const ::std::os::raw::c_char,
pub regionUVs: *mut f32,
pub uvs: *mut f32,
pub trianglesCount: ::std::os::raw::c_int,
pub triangles: *mut ::std::os::raw::c_ushort,
pub color: spColor,
pub hullLength: ::std::os::raw::c_int,
pub parentMesh: *mut spMeshAttachment,
pub edgesCount: ::std::os::raw::c_int,
pub edges: *mut ::std::os::raw::c_int,
pub width: f32,
pub height: f32,
}
#[test]
fn bindgen_test_layout_spMeshAttachment() {
assert_eq!(
::std::mem::size_of::<spMeshAttachment>(),
248usize,
concat!("Size of: ", stringify!(spMeshAttachment))
);
assert_eq!(
::std::mem::align_of::<spMeshAttachment>(),
8usize,
concat!("Alignment of ", stringify!(spMeshAttachment))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).rendererObject as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(rendererObject)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionOffsetX as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(regionOffsetX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionOffsetY as *const _ as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(regionOffsetY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionWidth as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(regionWidth)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionHeight as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(regionHeight)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spMeshAttachment>())).regionOriginalWidth as *const _ as usize
},
120usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(regionOriginalWidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spMeshAttachment>())).regionOriginalHeight as *const _ as usize
},
124usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(regionOriginalHeight)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionU as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(regionU)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionV as *const _ as usize },
132usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(regionV)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionU2 as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(regionU2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionV2 as *const _ as usize },
140usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(regionV2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionRotate as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(regionRotate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionDegrees as *const _ as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(regionDegrees)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).path as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(path)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).regionUVs as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(regionUVs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).uvs as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(uvs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).trianglesCount as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(trianglesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).triangles as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(triangles)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).color as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).hullLength as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(hullLength)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).parentMesh as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(parentMesh)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).edgesCount as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(edgesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).edges as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(edges)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).width as *const _ as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spMeshAttachment>())).height as *const _ as usize },
244usize,
concat!(
"Offset of field: ",
stringify!(spMeshAttachment),
"::",
stringify!(height)
)
);
}
extern "C" {
pub fn spMeshAttachment_create(name: *const ::std::os::raw::c_char) -> *mut spMeshAttachment;
}
extern "C" {
pub fn spMeshAttachment_updateUVs(self_: *mut spMeshAttachment);
}
extern "C" {
pub fn spMeshAttachment_setParentMesh(
self_: *mut spMeshAttachment,
parentMesh: *mut spMeshAttachment,
);
}
extern "C" {
pub fn spMeshAttachment_newLinkedMesh(self_: *mut spMeshAttachment) -> *mut spMeshAttachment;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spBoundingBoxAttachment {
pub super_: spVertexAttachment,
}
#[test]
fn bindgen_test_layout_spBoundingBoxAttachment() {
assert_eq!(
::std::mem::size_of::<spBoundingBoxAttachment>(),
96usize,
concat!("Size of: ", stringify!(spBoundingBoxAttachment))
);
assert_eq!(
::std::mem::align_of::<spBoundingBoxAttachment>(),
8usize,
concat!("Alignment of ", stringify!(spBoundingBoxAttachment))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spBoundingBoxAttachment>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spBoundingBoxAttachment),
"::",
stringify!(super_)
)
);
}
extern "C" {
pub fn spBoundingBoxAttachment_create(
name: *const ::std::os::raw::c_char,
) -> *mut spBoundingBoxAttachment;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spClippingAttachment {
pub super_: spVertexAttachment,
pub endSlot: *mut spSlotData,
}
#[test]
fn bindgen_test_layout_spClippingAttachment() {
assert_eq!(
::std::mem::size_of::<spClippingAttachment>(),
104usize,
concat!("Size of: ", stringify!(spClippingAttachment))
);
assert_eq!(
::std::mem::align_of::<spClippingAttachment>(),
8usize,
concat!("Alignment of ", stringify!(spClippingAttachment))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spClippingAttachment>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spClippingAttachment),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spClippingAttachment>())).endSlot as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(spClippingAttachment),
"::",
stringify!(endSlot)
)
);
}
extern "C" {
pub fn _spClippingAttachment_dispose(self_: *mut spAttachment);
}
extern "C" {
pub fn spClippingAttachment_create(
name: *const ::std::os::raw::c_char,
) -> *mut spClippingAttachment;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spPointAttachment {
pub super_: spAttachment,
pub x: f32,
pub y: f32,
pub rotation: f32,
pub color: spColor,
}
#[test]
fn bindgen_test_layout_spPointAttachment() {
assert_eq!(
::std::mem::size_of::<spPointAttachment>(),
72usize,
concat!("Size of: ", stringify!(spPointAttachment))
);
assert_eq!(
::std::mem::align_of::<spPointAttachment>(),
8usize,
concat!("Alignment of ", stringify!(spPointAttachment))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPointAttachment>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spPointAttachment),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPointAttachment>())).x as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spPointAttachment),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPointAttachment>())).y as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(spPointAttachment),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPointAttachment>())).rotation as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spPointAttachment),
"::",
stringify!(rotation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPointAttachment>())).color as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(spPointAttachment),
"::",
stringify!(color)
)
);
}
extern "C" {
pub fn spPointAttachment_create(name: *const ::std::os::raw::c_char) -> *mut spPointAttachment;
}
extern "C" {
pub fn spPointAttachment_computeWorldPosition(
self_: *mut spPointAttachment,
bone: *mut spBone,
x: *mut f32,
y: *mut f32,
);
}
extern "C" {
pub fn spPointAttachment_computeWorldRotation(
self_: *mut spPointAttachment,
bone: *mut spBone,
) -> f32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spIkConstraint {
pub data: *mut spIkConstraintData,
pub bonesCount: ::std::os::raw::c_int,
pub bones: *mut *mut spBone,
pub target: *mut spBone,
pub bendDirection: ::std::os::raw::c_int,
pub compress: ::std::os::raw::c_int,
pub stretch: ::std::os::raw::c_int,
pub mix: f32,
pub softness: f32,
pub active: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spIkConstraint() {
assert_eq!(
::std::mem::size_of::<spIkConstraint>(),
56usize,
concat!("Size of: ", stringify!(spIkConstraint))
);
assert_eq!(
::std::mem::align_of::<spIkConstraint>(),
8usize,
concat!("Alignment of ", stringify!(spIkConstraint))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraint>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraint),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraint>())).bonesCount as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraint),
"::",
stringify!(bonesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraint>())).bones as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraint),
"::",
stringify!(bones)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraint>())).target as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraint),
"::",
stringify!(target)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraint>())).bendDirection as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraint),
"::",
stringify!(bendDirection)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraint>())).compress as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraint),
"::",
stringify!(compress)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraint>())).stretch as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraint),
"::",
stringify!(stretch)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraint>())).mix as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraint),
"::",
stringify!(mix)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraint>())).softness as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraint),
"::",
stringify!(softness)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spIkConstraint>())).active as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(spIkConstraint),
"::",
stringify!(active)
)
);
}
extern "C" {
pub fn spIkConstraint_create(
data: *mut spIkConstraintData,
skeleton: *const spSkeleton,
) -> *mut spIkConstraint;
}
extern "C" {
pub fn spIkConstraint_dispose(self_: *mut spIkConstraint);
}
extern "C" {
pub fn spIkConstraint_apply(self_: *mut spIkConstraint);
}
extern "C" {
pub fn spIkConstraint_apply1(
bone: *mut spBone,
targetX: f32,
targetY: f32,
compress: ::std::os::raw::c_int,
stretch: ::std::os::raw::c_int,
uniform: ::std::os::raw::c_int,
alpha: f32,
);
}
extern "C" {
pub fn spIkConstraint_apply2(
parent: *mut spBone,
child: *mut spBone,
targetX: f32,
targetY: f32,
bendDirection: ::std::os::raw::c_int,
stretch: ::std::os::raw::c_int,
softness: f32,
alpha: f32,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spTransformConstraint {
pub data: *mut spTransformConstraintData,
pub bonesCount: ::std::os::raw::c_int,
pub bones: *mut *mut spBone,
pub target: *mut spBone,
pub rotateMix: f32,
pub translateMix: f32,
pub scaleMix: f32,
pub shearMix: f32,
pub active: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spTransformConstraint() {
assert_eq!(
::std::mem::size_of::<spTransformConstraint>(),
56usize,
concat!("Size of: ", stringify!(spTransformConstraint))
);
assert_eq!(
::std::mem::align_of::<spTransformConstraint>(),
8usize,
concat!("Alignment of ", stringify!(spTransformConstraint))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTransformConstraint>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraint),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraint>())).bonesCount as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraint),
"::",
stringify!(bonesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTransformConstraint>())).bones as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraint),
"::",
stringify!(bones)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTransformConstraint>())).target as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraint),
"::",
stringify!(target)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTransformConstraint>())).rotateMix as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraint),
"::",
stringify!(rotateMix)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTransformConstraint>())).translateMix as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraint),
"::",
stringify!(translateMix)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTransformConstraint>())).scaleMix as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraint),
"::",
stringify!(scaleMix)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTransformConstraint>())).shearMix as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraint),
"::",
stringify!(shearMix)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTransformConstraint>())).active as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spTransformConstraint),
"::",
stringify!(active)
)
);
}
extern "C" {
pub fn spTransformConstraint_create(
data: *mut spTransformConstraintData,
skeleton: *const spSkeleton,
) -> *mut spTransformConstraint;
}
extern "C" {
pub fn spTransformConstraint_dispose(self_: *mut spTransformConstraint);
}
extern "C" {
pub fn spTransformConstraint_apply(self_: *mut spTransformConstraint);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spPathAttachment {
pub super_: spVertexAttachment,
pub lengthsLength: ::std::os::raw::c_int,
pub lengths: *mut f32,
pub closed: ::std::os::raw::c_int,
pub constantSpeed: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spPathAttachment() {
assert_eq!(
::std::mem::size_of::<spPathAttachment>(),
120usize,
concat!("Size of: ", stringify!(spPathAttachment))
);
assert_eq!(
::std::mem::align_of::<spPathAttachment>(),
8usize,
concat!("Alignment of ", stringify!(spPathAttachment))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathAttachment>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spPathAttachment),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathAttachment>())).lengthsLength as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(spPathAttachment),
"::",
stringify!(lengthsLength)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathAttachment>())).lengths as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(spPathAttachment),
"::",
stringify!(lengths)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathAttachment>())).closed as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(spPathAttachment),
"::",
stringify!(closed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathAttachment>())).constantSpeed as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(spPathAttachment),
"::",
stringify!(constantSpeed)
)
);
}
extern "C" {
pub fn spPathAttachment_create(name: *const ::std::os::raw::c_char) -> *mut spPathAttachment;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spPathConstraint {
pub data: *mut spPathConstraintData,
pub bonesCount: ::std::os::raw::c_int,
pub bones: *mut *mut spBone,
pub target: *mut spSlot,
pub position: f32,
pub spacing: f32,
pub rotateMix: f32,
pub translateMix: f32,
pub spacesCount: ::std::os::raw::c_int,
pub spaces: *mut f32,
pub positionsCount: ::std::os::raw::c_int,
pub positions: *mut f32,
pub worldCount: ::std::os::raw::c_int,
pub world: *mut f32,
pub curvesCount: ::std::os::raw::c_int,
pub curves: *mut f32,
pub lengthsCount: ::std::os::raw::c_int,
pub lengths: *mut f32,
pub segments: [f32; 10usize],
pub active: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spPathConstraint() {
assert_eq!(
::std::mem::size_of::<spPathConstraint>(),
176usize,
concat!("Size of: ", stringify!(spPathConstraint))
);
assert_eq!(
::std::mem::align_of::<spPathConstraint>(),
8usize,
concat!("Alignment of ", stringify!(spPathConstraint))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).bonesCount as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(bonesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).bones as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(bones)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).target as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(target)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).position as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(position)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).spacing as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(spacing)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).rotateMix as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(rotateMix)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).translateMix as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(translateMix)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).spacesCount as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(spacesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).spaces as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(spaces)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).positionsCount as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(positionsCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).positions as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(positions)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).worldCount as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(worldCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).world as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(world)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).curvesCount as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(curvesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).curves as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(curves)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).lengthsCount as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(lengthsCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).lengths as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(lengths)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).segments as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(segments)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPathConstraint>())).active as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(spPathConstraint),
"::",
stringify!(active)
)
);
}
extern "C" {
pub fn spPathConstraint_create(
data: *mut spPathConstraintData,
skeleton: *const spSkeleton,
) -> *mut spPathConstraint;
}
extern "C" {
pub fn spPathConstraint_dispose(self_: *mut spPathConstraint);
}
extern "C" {
pub fn spPathConstraint_apply(self_: *mut spPathConstraint);
}
extern "C" {
pub fn spPathConstraint_computeWorldPositions(
self_: *mut spPathConstraint,
path: *mut spPathAttachment,
spacesCount: ::std::os::raw::c_int,
tangents: ::std::os::raw::c_int,
percentPosition: ::std::os::raw::c_int,
percentSpacing: ::std::os::raw::c_int,
) -> *mut f32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spSkeleton {
pub data: *mut spSkeletonData,
pub bonesCount: ::std::os::raw::c_int,
pub bones: *mut *mut spBone,
pub root: *mut spBone,
pub slotsCount: ::std::os::raw::c_int,
pub slots: *mut *mut spSlot,
pub drawOrder: *mut *mut spSlot,
pub ikConstraintsCount: ::std::os::raw::c_int,
pub ikConstraints: *mut *mut spIkConstraint,
pub transformConstraintsCount: ::std::os::raw::c_int,
pub transformConstraints: *mut *mut spTransformConstraint,
pub pathConstraintsCount: ::std::os::raw::c_int,
pub pathConstraints: *mut *mut spPathConstraint,
pub skin: *mut spSkin,
pub color: spColor,
pub time: f32,
pub scaleX: f32,
pub scaleY: f32,
pub x: f32,
pub y: f32,
}
#[test]
fn bindgen_test_layout_spSkeleton() {
assert_eq!(
::std::mem::size_of::<spSkeleton>(),
152usize,
concat!("Size of: ", stringify!(spSkeleton))
);
assert_eq!(
::std::mem::align_of::<spSkeleton>(),
8usize,
concat!("Alignment of ", stringify!(spSkeleton))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).bonesCount as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(bonesCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).bones as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(bones)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).root as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(root)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).slotsCount as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(slotsCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).slots as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(slots)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).drawOrder as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(drawOrder)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).ikConstraintsCount as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(ikConstraintsCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).ikConstraints as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(ikConstraints)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spSkeleton>())).transformConstraintsCount as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(transformConstraintsCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).transformConstraints as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(transformConstraints)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).pathConstraintsCount as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(pathConstraintsCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).pathConstraints as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(pathConstraints)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).skin as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(skin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).color as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).time as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).scaleX as *const _ as usize },
132usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(scaleX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).scaleY as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(scaleY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).x as *const _ as usize },
140usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeleton>())).y as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(spSkeleton),
"::",
stringify!(y)
)
);
}
extern "C" {
pub fn spSkeleton_create(data: *mut spSkeletonData) -> *mut spSkeleton;
}
extern "C" {
pub fn spSkeleton_dispose(self_: *mut spSkeleton);
}
extern "C" {
pub fn spSkeleton_updateCache(self_: *mut spSkeleton);
}
extern "C" {
pub fn spSkeleton_updateWorldTransform(self_: *const spSkeleton);
}
extern "C" {
pub fn spSkeleton_setToSetupPose(self_: *const spSkeleton);
}
extern "C" {
pub fn spSkeleton_setBonesToSetupPose(self_: *const spSkeleton);
}
extern "C" {
pub fn spSkeleton_setSlotsToSetupPose(self_: *const spSkeleton);
}
extern "C" {
pub fn spSkeleton_findBone(
self_: *const spSkeleton,
boneName: *const ::std::os::raw::c_char,
) -> *mut spBone;
}
extern "C" {
pub fn spSkeleton_findBoneIndex(
self_: *const spSkeleton,
boneName: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spSkeleton_findSlot(
self_: *const spSkeleton,
slotName: *const ::std::os::raw::c_char,
) -> *mut spSlot;
}
extern "C" {
pub fn spSkeleton_findSlotIndex(
self_: *const spSkeleton,
slotName: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spSkeleton_setSkin(self_: *mut spSkeleton, skin: *mut spSkin);
}
extern "C" {
pub fn spSkeleton_setSkinByName(
self_: *mut spSkeleton,
skinName: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spSkeleton_getAttachmentForSlotName(
self_: *const spSkeleton,
slotName: *const ::std::os::raw::c_char,
attachmentName: *const ::std::os::raw::c_char,
) -> *mut spAttachment;
}
extern "C" {
pub fn spSkeleton_getAttachmentForSlotIndex(
self_: *const spSkeleton,
slotIndex: ::std::os::raw::c_int,
attachmentName: *const ::std::os::raw::c_char,
) -> *mut spAttachment;
}
extern "C" {
pub fn spSkeleton_setAttachment(
self_: *mut spSkeleton,
slotName: *const ::std::os::raw::c_char,
attachmentName: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spSkeleton_findIkConstraint(
self_: *const spSkeleton,
constraintName: *const ::std::os::raw::c_char,
) -> *mut spIkConstraint;
}
extern "C" {
pub fn spSkeleton_findTransformConstraint(
self_: *const spSkeleton,
constraintName: *const ::std::os::raw::c_char,
) -> *mut spTransformConstraint;
}
extern "C" {
pub fn spSkeleton_findPathConstraint(
self_: *const spSkeleton,
constraintName: *const ::std::os::raw::c_char,
) -> *mut spPathConstraint;
}
extern "C" {
pub fn spSkeleton_update(self_: *mut spSkeleton, deltaTime: f32);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spPolygon {
pub vertices: *mut f32,
pub count: ::std::os::raw::c_int,
pub capacity: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_spPolygon() {
assert_eq!(
::std::mem::size_of::<spPolygon>(),
16usize,
concat!("Size of: ", stringify!(spPolygon))
);
assert_eq!(
::std::mem::align_of::<spPolygon>(),
8usize,
concat!("Alignment of ", stringify!(spPolygon))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPolygon>())).vertices as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spPolygon),
"::",
stringify!(vertices)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPolygon>())).count as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spPolygon),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spPolygon>())).capacity as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(spPolygon),
"::",
stringify!(capacity)
)
);
}
extern "C" {
pub fn spPolygon_create(capacity: ::std::os::raw::c_int) -> *mut spPolygon;
}
extern "C" {
pub fn spPolygon_dispose(self_: *mut spPolygon);
}
extern "C" {
pub fn spPolygon_containsPoint(
polygon: *mut spPolygon,
x: f32,
y: f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spPolygon_intersectsSegment(
polygon: *mut spPolygon,
x1: f32,
y1: f32,
x2: f32,
y2: f32,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spSkeletonBounds {
pub count: ::std::os::raw::c_int,
pub boundingBoxes: *mut *mut spBoundingBoxAttachment,
pub polygons: *mut *mut spPolygon,
pub minX: f32,
pub minY: f32,
pub maxX: f32,
pub maxY: f32,
}
#[test]
fn bindgen_test_layout_spSkeletonBounds() {
assert_eq!(
::std::mem::size_of::<spSkeletonBounds>(),
40usize,
concat!("Size of: ", stringify!(spSkeletonBounds))
);
assert_eq!(
::std::mem::align_of::<spSkeletonBounds>(),
8usize,
concat!("Alignment of ", stringify!(spSkeletonBounds))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonBounds>())).count as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonBounds),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonBounds>())).boundingBoxes as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonBounds),
"::",
stringify!(boundingBoxes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonBounds>())).polygons as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonBounds),
"::",
stringify!(polygons)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonBounds>())).minX as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonBounds),
"::",
stringify!(minX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonBounds>())).minY as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonBounds),
"::",
stringify!(minY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonBounds>())).maxX as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonBounds),
"::",
stringify!(maxX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonBounds>())).maxY as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonBounds),
"::",
stringify!(maxY)
)
);
}
extern "C" {
pub fn spSkeletonBounds_create() -> *mut spSkeletonBounds;
}
extern "C" {
pub fn spSkeletonBounds_dispose(self_: *mut spSkeletonBounds);
}
extern "C" {
pub fn spSkeletonBounds_update(
self_: *mut spSkeletonBounds,
skeleton: *mut spSkeleton,
updateAabb: ::std::os::raw::c_int,
);
}
extern "C" {
#[doc = " Returns true if the axis aligned bounding box contains the point."]
pub fn spSkeletonBounds_aabbContainsPoint(
self_: *mut spSkeletonBounds,
x: f32,
y: f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Returns true if the axis aligned bounding box intersects the line segment."]
pub fn spSkeletonBounds_aabbIntersectsSegment(
self_: *mut spSkeletonBounds,
x1: f32,
y1: f32,
x2: f32,
y2: f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds."]
pub fn spSkeletonBounds_aabbIntersectsSkeleton(
self_: *mut spSkeletonBounds,
bounds: *mut spSkeletonBounds,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more"]
#[doc = " efficient to only call this method if spSkeletonBounds_aabbContainsPoint returns true."]
pub fn spSkeletonBounds_containsPoint(
self_: *mut spSkeletonBounds,
x: f32,
y: f32,
) -> *mut spBoundingBoxAttachment;
}
extern "C" {
#[doc = " Returns the first bounding box attachment that contains the line segment, or null. When doing many checks, it is usually"]
#[doc = " more efficient to only call this method if spSkeletonBounds_aabbIntersectsSegment returns true."]
pub fn spSkeletonBounds_intersectsSegment(
self_: *mut spSkeletonBounds,
x1: f32,
y1: f32,
x2: f32,
y2: f32,
) -> *mut spBoundingBoxAttachment;
}
extern "C" {
#[doc = " Returns the polygon for the specified bounding box, or null."]
pub fn spSkeletonBounds_getPolygon(
self_: *mut spSkeletonBounds,
boundingBox: *mut spBoundingBoxAttachment,
) -> *mut spPolygon;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spSkeletonBinary {
pub scale: f32,
pub attachmentLoader: *mut spAttachmentLoader,
pub error: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_spSkeletonBinary() {
assert_eq!(
::std::mem::size_of::<spSkeletonBinary>(),
24usize,
concat!("Size of: ", stringify!(spSkeletonBinary))
);
assert_eq!(
::std::mem::align_of::<spSkeletonBinary>(),
8usize,
concat!("Alignment of ", stringify!(spSkeletonBinary))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonBinary>())).scale as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonBinary),
"::",
stringify!(scale)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spSkeletonBinary>())).attachmentLoader as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonBinary),
"::",
stringify!(attachmentLoader)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonBinary>())).error as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonBinary),
"::",
stringify!(error)
)
);
}
extern "C" {
pub fn spSkeletonBinary_createWithLoader(
attachmentLoader: *mut spAttachmentLoader,
) -> *mut spSkeletonBinary;
}
extern "C" {
pub fn spSkeletonBinary_create(atlas: *mut spAtlas) -> *mut spSkeletonBinary;
}
extern "C" {
pub fn spSkeletonBinary_dispose(self_: *mut spSkeletonBinary);
}
extern "C" {
pub fn spSkeletonBinary_readSkeletonData(
self_: *mut spSkeletonBinary,
binary: *const ::std::os::raw::c_uchar,
length: ::std::os::raw::c_int,
) -> *mut spSkeletonData;
}
extern "C" {
pub fn spSkeletonBinary_readSkeletonDataFile(
self_: *mut spSkeletonBinary,
path: *const ::std::os::raw::c_char,
) -> *mut spSkeletonData;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spSkeletonJson {
pub scale: f32,
pub attachmentLoader: *mut spAttachmentLoader,
pub error: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_spSkeletonJson() {
assert_eq!(
::std::mem::size_of::<spSkeletonJson>(),
24usize,
concat!("Size of: ", stringify!(spSkeletonJson))
);
assert_eq!(
::std::mem::align_of::<spSkeletonJson>(),
8usize,
concat!("Alignment of ", stringify!(spSkeletonJson))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonJson>())).scale as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonJson),
"::",
stringify!(scale)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonJson>())).attachmentLoader as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonJson),
"::",
stringify!(attachmentLoader)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonJson>())).error as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonJson),
"::",
stringify!(error)
)
);
}
extern "C" {
pub fn spSkeletonJson_createWithLoader(
attachmentLoader: *mut spAttachmentLoader,
) -> *mut spSkeletonJson;
}
extern "C" {
pub fn spSkeletonJson_create(atlas: *mut spAtlas) -> *mut spSkeletonJson;
}
extern "C" {
pub fn spSkeletonJson_dispose(self_: *mut spSkeletonJson);
}
extern "C" {
pub fn spSkeletonJson_readSkeletonData(
self_: *mut spSkeletonJson,
json: *const ::std::os::raw::c_char,
) -> *mut spSkeletonData;
}
extern "C" {
pub fn spSkeletonJson_readSkeletonDataFile(
self_: *mut spSkeletonJson,
path: *const ::std::os::raw::c_char,
) -> *mut spSkeletonData;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spTriangulator {
pub convexPolygons: *mut spArrayFloatArray,
pub convexPolygonsIndices: *mut spArrayShortArray,
pub indicesArray: *mut spShortArray,
pub isConcaveArray: *mut spIntArray,
pub triangles: *mut spShortArray,
pub polygonPool: *mut spArrayFloatArray,
pub polygonIndicesPool: *mut spArrayShortArray,
}
#[test]
fn bindgen_test_layout_spTriangulator() {
assert_eq!(
::std::mem::size_of::<spTriangulator>(),
56usize,
concat!("Size of: ", stringify!(spTriangulator))
);
assert_eq!(
::std::mem::align_of::<spTriangulator>(),
8usize,
concat!("Alignment of ", stringify!(spTriangulator))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTriangulator>())).convexPolygons as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spTriangulator),
"::",
stringify!(convexPolygons)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTriangulator>())).convexPolygonsIndices as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(spTriangulator),
"::",
stringify!(convexPolygonsIndices)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTriangulator>())).indicesArray as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spTriangulator),
"::",
stringify!(indicesArray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTriangulator>())).isConcaveArray as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spTriangulator),
"::",
stringify!(isConcaveArray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTriangulator>())).triangles as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spTriangulator),
"::",
stringify!(triangles)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spTriangulator>())).polygonPool as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spTriangulator),
"::",
stringify!(polygonPool)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spTriangulator>())).polygonIndicesPool as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(spTriangulator),
"::",
stringify!(polygonIndicesPool)
)
);
}
extern "C" {
pub fn spTriangulator_create() -> *mut spTriangulator;
}
extern "C" {
pub fn spTriangulator_triangulate(
self_: *mut spTriangulator,
verticesArray: *mut spFloatArray,
) -> *mut spShortArray;
}
extern "C" {
pub fn spTriangulator_decompose(
self_: *mut spTriangulator,
verticesArray: *mut spFloatArray,
triangles: *mut spShortArray,
) -> *mut spArrayFloatArray;
}
extern "C" {
pub fn spTriangulator_dispose(self_: *mut spTriangulator);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spSkeletonClipping {
pub triangulator: *mut spTriangulator,
pub clippingPolygon: *mut spFloatArray,
pub clipOutput: *mut spFloatArray,
pub clippedVertices: *mut spFloatArray,
pub clippedUVs: *mut spFloatArray,
pub clippedTriangles: *mut spUnsignedShortArray,
pub scratch: *mut spFloatArray,
pub clipAttachment: *mut spClippingAttachment,
pub clippingPolygons: *mut spArrayFloatArray,
}
#[test]
fn bindgen_test_layout_spSkeletonClipping() {
assert_eq!(
::std::mem::size_of::<spSkeletonClipping>(),
72usize,
concat!("Size of: ", stringify!(spSkeletonClipping))
);
assert_eq!(
::std::mem::align_of::<spSkeletonClipping>(),
8usize,
concat!("Alignment of ", stringify!(spSkeletonClipping))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonClipping>())).triangulator as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonClipping),
"::",
stringify!(triangulator)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spSkeletonClipping>())).clippingPolygon as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonClipping),
"::",
stringify!(clippingPolygon)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonClipping>())).clipOutput as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonClipping),
"::",
stringify!(clipOutput)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spSkeletonClipping>())).clippedVertices as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonClipping),
"::",
stringify!(clippedVertices)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonClipping>())).clippedUVs as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonClipping),
"::",
stringify!(clippedUVs)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spSkeletonClipping>())).clippedTriangles as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonClipping),
"::",
stringify!(clippedTriangles)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSkeletonClipping>())).scratch as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonClipping),
"::",
stringify!(scratch)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spSkeletonClipping>())).clipAttachment as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonClipping),
"::",
stringify!(clipAttachment)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<spSkeletonClipping>())).clippingPolygons as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(spSkeletonClipping),
"::",
stringify!(clippingPolygons)
)
);
}
extern "C" {
pub fn spSkeletonClipping_create() -> *mut spSkeletonClipping;
}
extern "C" {
pub fn spSkeletonClipping_clipStart(
self_: *mut spSkeletonClipping,
slot: *mut spSlot,
clip: *mut spClippingAttachment,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spSkeletonClipping_clipEnd(self_: *mut spSkeletonClipping, slot: *mut spSlot);
}
extern "C" {
pub fn spSkeletonClipping_clipEnd2(self_: *mut spSkeletonClipping);
}
extern "C" {
pub fn spSkeletonClipping_isClipping(self_: *mut spSkeletonClipping) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn spSkeletonClipping_clipTriangles(
self_: *mut spSkeletonClipping,
vertices: *mut f32,
verticesLength: ::std::os::raw::c_int,
triangles: *mut ::std::os::raw::c_ushort,
trianglesLength: ::std::os::raw::c_int,
uvs: *mut f32,
stride: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn spSkeletonClipping_dispose(self_: *mut spSkeletonClipping);
}
pub type spVertexEffectBegin = ::std::option::Option<
unsafe extern "C" fn(self_: *mut spVertexEffect, skeleton: *mut spSkeleton),
>;
pub type spVertexEffectTransform = ::std::option::Option<
unsafe extern "C" fn(
self_: *mut spVertexEffect,
x: *mut f32,
y: *mut f32,
u: *mut f32,
v: *mut f32,
light: *mut spColor,
dark: *mut spColor,
),
>;
pub type spVertexEffectEnd =
::std::option::Option<unsafe extern "C" fn(self_: *mut spVertexEffect)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spVertexEffect {
pub begin: spVertexEffectBegin,
pub transform: spVertexEffectTransform,
pub end: spVertexEffectEnd,
}
#[test]
fn bindgen_test_layout_spVertexEffect() {
assert_eq!(
::std::mem::size_of::<spVertexEffect>(),
24usize,
concat!("Size of: ", stringify!(spVertexEffect))
);
assert_eq!(
::std::mem::align_of::<spVertexEffect>(),
8usize,
concat!("Alignment of ", stringify!(spVertexEffect))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spVertexEffect>())).begin as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spVertexEffect),
"::",
stringify!(begin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spVertexEffect>())).transform as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spVertexEffect),
"::",
stringify!(transform)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spVertexEffect>())).end as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spVertexEffect),
"::",
stringify!(end)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spJitterVertexEffect {
pub super_: spVertexEffect,
pub jitterX: f32,
pub jitterY: f32,
}
#[test]
fn bindgen_test_layout_spJitterVertexEffect() {
assert_eq!(
::std::mem::size_of::<spJitterVertexEffect>(),
32usize,
concat!("Size of: ", stringify!(spJitterVertexEffect))
);
assert_eq!(
::std::mem::align_of::<spJitterVertexEffect>(),
8usize,
concat!("Alignment of ", stringify!(spJitterVertexEffect))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spJitterVertexEffect>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spJitterVertexEffect),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spJitterVertexEffect>())).jitterX as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spJitterVertexEffect),
"::",
stringify!(jitterX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spJitterVertexEffect>())).jitterY as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(spJitterVertexEffect),
"::",
stringify!(jitterY)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spSwirlVertexEffect {
pub super_: spVertexEffect,
pub centerX: f32,
pub centerY: f32,
pub radius: f32,
pub angle: f32,
pub worldX: f32,
pub worldY: f32,
}
#[test]
fn bindgen_test_layout_spSwirlVertexEffect() {
assert_eq!(
::std::mem::size_of::<spSwirlVertexEffect>(),
48usize,
concat!("Size of: ", stringify!(spSwirlVertexEffect))
);
assert_eq!(
::std::mem::align_of::<spSwirlVertexEffect>(),
8usize,
concat!("Alignment of ", stringify!(spSwirlVertexEffect))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSwirlVertexEffect>())).super_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spSwirlVertexEffect),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSwirlVertexEffect>())).centerX as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spSwirlVertexEffect),
"::",
stringify!(centerX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSwirlVertexEffect>())).centerY as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(spSwirlVertexEffect),
"::",
stringify!(centerY)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSwirlVertexEffect>())).radius as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spSwirlVertexEffect),
"::",
stringify!(radius)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSwirlVertexEffect>())).angle as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(spSwirlVertexEffect),
"::",
stringify!(angle)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSwirlVertexEffect>())).worldX as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spSwirlVertexEffect),
"::",
stringify!(worldX)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<spSwirlVertexEffect>())).worldY as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(spSwirlVertexEffect),
"::",
stringify!(worldY)
)
);
}
extern "C" {
pub fn spJitterVertexEffect_create(jitterX: f32, jitterY: f32) -> *mut spJitterVertexEffect;
}
extern "C" {
pub fn spJitterVertexEffect_dispose(effect: *mut spJitterVertexEffect);
}
extern "C" {
pub fn spSwirlVertexEffect_create(radius: f32) -> *mut spSwirlVertexEffect;
}
extern "C" {
pub fn spSwirlVertexEffect_dispose(effect: *mut spSwirlVertexEffect);
}
extern "C" {
pub fn _spReadFile(
path: *const ::std::os::raw::c_char,
length: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}