pub const __WORDSIZE: u32 = 64;
pub const __DARWIN_ONLY_64_BIT_INO_T: u32 = 0;
pub const __DARWIN_ONLY_UNIX_CONFORMANCE: u32 = 1;
pub const __DARWIN_ONLY_VERS_1050: u32 = 0;
pub const __DARWIN_UNIX03: u32 = 1;
pub const __DARWIN_64_BIT_INO_T: u32 = 1;
pub const __DARWIN_VERS_1050: u32 = 1;
pub const __DARWIN_NON_CANCELABLE: u32 = 0;
pub const __DARWIN_SUF_64_BIT_INO_T: &'static [u8; 9usize] = b"$INODE64\0";
pub const __DARWIN_SUF_1050: &'static [u8; 6usize] = b"$1050\0";
pub const __DARWIN_SUF_EXTSN: &'static [u8; 14usize] = b"$DARWIN_EXTSN\0";
pub const __DARWIN_C_ANSI: u32 = 4096;
pub const __DARWIN_C_FULL: u32 = 900000;
pub const __DARWIN_C_LEVEL: u32 = 900000;
pub const __STDC_WANT_LIB_EXT1__: u32 = 1;
pub const __DARWIN_NO_LONG_LONG: u32 = 0;
pub const _DARWIN_FEATURE_64_BIT_INODE: u32 = 1;
pub const _DARWIN_FEATURE_ONLY_UNIX_CONFORMANCE: u32 = 1;
pub const _DARWIN_FEATURE_UNIX_CONFORMANCE: u32 = 3;
pub const __PTHREAD_SIZE__: u32 = 8176;
pub const __PTHREAD_ATTR_SIZE__: u32 = 56;
pub const __PTHREAD_MUTEXATTR_SIZE__: u32 = 8;
pub const __PTHREAD_MUTEX_SIZE__: u32 = 56;
pub const __PTHREAD_CONDATTR_SIZE__: u32 = 8;
pub const __PTHREAD_COND_SIZE__: u32 = 40;
pub const __PTHREAD_ONCE_SIZE__: u32 = 8;
pub const __PTHREAD_RWLOCK_SIZE__: u32 = 192;
pub const __PTHREAD_RWLOCKATTR_SIZE__: u32 = 16;
pub const INT8_MAX: u32 = 127;
pub const INT16_MAX: u32 = 32767;
pub const INT32_MAX: u32 = 2147483647;
pub const INT64_MAX: u64 = 9223372036854775807;
pub const INT8_MIN: i32 = -128;
pub const INT16_MIN: i32 = -32768;
pub const INT32_MIN: i32 = -2147483648;
pub const INT64_MIN: i64 = -9223372036854775808;
pub const UINT8_MAX: u32 = 255;
pub const UINT16_MAX: u32 = 65535;
pub const UINT32_MAX: u32 = 4294967295;
pub const UINT64_MAX: i32 = -1;
pub const INT_LEAST8_MIN: i32 = -128;
pub const INT_LEAST16_MIN: i32 = -32768;
pub const INT_LEAST32_MIN: i32 = -2147483648;
pub const INT_LEAST64_MIN: i64 = -9223372036854775808;
pub const INT_LEAST8_MAX: u32 = 127;
pub const INT_LEAST16_MAX: u32 = 32767;
pub const INT_LEAST32_MAX: u32 = 2147483647;
pub const INT_LEAST64_MAX: u64 = 9223372036854775807;
pub const UINT_LEAST8_MAX: u32 = 255;
pub const UINT_LEAST16_MAX: u32 = 65535;
pub const UINT_LEAST32_MAX: u32 = 4294967295;
pub const UINT_LEAST64_MAX: i32 = -1;
pub const INT_FAST8_MIN: i32 = -128;
pub const INT_FAST16_MIN: i32 = -32768;
pub const INT_FAST32_MIN: i32 = -2147483648;
pub const INT_FAST64_MIN: i64 = -9223372036854775808;
pub const INT_FAST8_MAX: u32 = 127;
pub const INT_FAST16_MAX: u32 = 32767;
pub const INT_FAST32_MAX: u32 = 2147483647;
pub const INT_FAST64_MAX: u64 = 9223372036854775807;
pub const UINT_FAST8_MAX: u32 = 255;
pub const UINT_FAST16_MAX: u32 = 65535;
pub const UINT_FAST32_MAX: u32 = 4294967295;
pub const UINT_FAST64_MAX: i32 = -1;
pub const INTPTR_MAX: u64 = 9223372036854775807;
pub const INTPTR_MIN: i64 = -9223372036854775808;
pub const UINTPTR_MAX: i32 = -1;
pub const SIZE_MAX: i32 = -1;
pub const RSIZE_MAX: i32 = -1;
pub const WINT_MIN: i32 = -2147483648;
pub const WINT_MAX: u32 = 2147483647;
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
pub const FNA3D_RENDERTARGET_TYPE_2D: u32 = 0;
pub const FNA3D_RENDERTARGET_TYPE_CUBE: u32 = 1;
pub const FNA3D_ABI_VERSION: u32 = 0;
pub const FNA3D_MAJOR_VERSION: u32 = 20;
pub const FNA3D_MINOR_VERSION: u32 = 11;
pub const FNA3D_PATCH_VERSION: u32 = 0;
pub type int_least8_t = i8;
pub type int_least16_t = i16;
pub type int_least32_t = i32;
pub type int_least64_t = i64;
pub type uint_least8_t = u8;
pub type uint_least16_t = u16;
pub type uint_least32_t = u32;
pub type uint_least64_t = u64;
pub type int_fast8_t = i8;
pub type int_fast16_t = i16;
pub type int_fast32_t = i32;
pub type int_fast64_t = i64;
pub type uint_fast8_t = u8;
pub type uint_fast16_t = u16;
pub type uint_fast32_t = u32;
pub type uint_fast64_t = u64;
pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_longlong;
pub type __uint64_t = ::std::os::raw::c_ulonglong;
pub type __darwin_intptr_t = ::std::os::raw::c_long;
pub type __darwin_natural_t = ::std::os::raw::c_uint;
pub type __darwin_ct_rune_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __mbstate_t {
pub __mbstate8: [::std::os::raw::c_char; 128usize],
pub _mbstateL: ::std::os::raw::c_longlong,
_bindgen_union_align: [u64; 16usize],
}
#[test]
fn bindgen_test_layout___mbstate_t() {
assert_eq!(
::std::mem::size_of::<__mbstate_t>(),
128usize,
concat!("Size of: ", stringify!(__mbstate_t))
);
assert_eq!(
::std::mem::align_of::<__mbstate_t>(),
8usize,
concat!("Alignment of ", stringify!(__mbstate_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__mbstate_t>())).__mbstate8 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t),
"::",
stringify!(__mbstate8)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__mbstate_t>()))._mbstateL as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t),
"::",
stringify!(_mbstateL)
)
);
}
pub type __darwin_mbstate_t = __mbstate_t;
pub type __darwin_ptrdiff_t = ::std::os::raw::c_long;
pub type __darwin_size_t = ::std::os::raw::c_ulong;
pub type __darwin_va_list = __builtin_va_list;
pub type __darwin_wchar_t = ::std::os::raw::c_int;
pub type __darwin_rune_t = __darwin_wchar_t;
pub type __darwin_wint_t = ::std::os::raw::c_int;
pub type __darwin_clock_t = ::std::os::raw::c_ulong;
pub type __darwin_socklen_t = __uint32_t;
pub type __darwin_ssize_t = ::std::os::raw::c_long;
pub type __darwin_time_t = ::std::os::raw::c_long;
pub type __darwin_blkcnt_t = __int64_t;
pub type __darwin_blksize_t = __int32_t;
pub type __darwin_dev_t = __int32_t;
pub type __darwin_fsblkcnt_t = ::std::os::raw::c_uint;
pub type __darwin_fsfilcnt_t = ::std::os::raw::c_uint;
pub type __darwin_gid_t = __uint32_t;
pub type __darwin_id_t = __uint32_t;
pub type __darwin_ino64_t = __uint64_t;
pub type __darwin_ino_t = __darwin_ino64_t;
pub type __darwin_mach_port_name_t = __darwin_natural_t;
pub type __darwin_mach_port_t = __darwin_mach_port_name_t;
pub type __darwin_mode_t = __uint16_t;
pub type __darwin_off_t = __int64_t;
pub type __darwin_pid_t = __int32_t;
pub type __darwin_sigset_t = __uint32_t;
pub type __darwin_suseconds_t = __int32_t;
pub type __darwin_uid_t = __uint32_t;
pub type __darwin_useconds_t = __uint32_t;
pub type __darwin_uuid_t = [::std::os::raw::c_uchar; 16usize];
pub type __darwin_uuid_string_t = [::std::os::raw::c_char; 37usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __darwin_pthread_handler_rec {
pub __routine: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
pub __arg: *mut ::std::os::raw::c_void,
pub __next: *mut __darwin_pthread_handler_rec,
}
#[test]
fn bindgen_test_layout___darwin_pthread_handler_rec() {
assert_eq!(
::std::mem::size_of::<__darwin_pthread_handler_rec>(),
24usize,
concat!("Size of: ", stringify!(__darwin_pthread_handler_rec))
);
assert_eq!(
::std::mem::align_of::<__darwin_pthread_handler_rec>(),
8usize,
concat!("Alignment of ", stringify!(__darwin_pthread_handler_rec))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__darwin_pthread_handler_rec>())).__routine as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__darwin_pthread_handler_rec),
"::",
stringify!(__routine)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__darwin_pthread_handler_rec>())).__arg as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(__darwin_pthread_handler_rec),
"::",
stringify!(__arg)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__darwin_pthread_handler_rec>())).__next as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(__darwin_pthread_handler_rec),
"::",
stringify!(__next)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _opaque_pthread_attr_t {
pub __sig: ::std::os::raw::c_long,
pub __opaque: [::std::os::raw::c_char; 56usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_attr_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_attr_t>(),
64usize,
concat!("Size of: ", stringify!(_opaque_pthread_attr_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_attr_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_attr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_attr_t>())).__sig as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_attr_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_attr_t>())).__opaque as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_attr_t),
"::",
stringify!(__opaque)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _opaque_pthread_cond_t {
pub __sig: ::std::os::raw::c_long,
pub __opaque: [::std::os::raw::c_char; 40usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_cond_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_cond_t>(),
48usize,
concat!("Size of: ", stringify!(_opaque_pthread_cond_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_cond_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_cond_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_cond_t>())).__sig as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_cond_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_cond_t>())).__opaque as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_cond_t),
"::",
stringify!(__opaque)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _opaque_pthread_condattr_t {
pub __sig: ::std::os::raw::c_long,
pub __opaque: [::std::os::raw::c_char; 8usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_condattr_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_condattr_t>(),
16usize,
concat!("Size of: ", stringify!(_opaque_pthread_condattr_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_condattr_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_condattr_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_condattr_t>())).__sig as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_condattr_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_condattr_t>())).__opaque as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_condattr_t),
"::",
stringify!(__opaque)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _opaque_pthread_mutex_t {
pub __sig: ::std::os::raw::c_long,
pub __opaque: [::std::os::raw::c_char; 56usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_mutex_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_mutex_t>(),
64usize,
concat!("Size of: ", stringify!(_opaque_pthread_mutex_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_mutex_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_mutex_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_mutex_t>())).__sig as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_mutex_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_mutex_t>())).__opaque as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_mutex_t),
"::",
stringify!(__opaque)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _opaque_pthread_mutexattr_t {
pub __sig: ::std::os::raw::c_long,
pub __opaque: [::std::os::raw::c_char; 8usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_mutexattr_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_mutexattr_t>(),
16usize,
concat!("Size of: ", stringify!(_opaque_pthread_mutexattr_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_mutexattr_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_mutexattr_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_mutexattr_t>())).__sig as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_mutexattr_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_mutexattr_t>())).__opaque as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_mutexattr_t),
"::",
stringify!(__opaque)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _opaque_pthread_once_t {
pub __sig: ::std::os::raw::c_long,
pub __opaque: [::std::os::raw::c_char; 8usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_once_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_once_t>(),
16usize,
concat!("Size of: ", stringify!(_opaque_pthread_once_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_once_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_once_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_once_t>())).__sig as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_once_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_once_t>())).__opaque as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_once_t),
"::",
stringify!(__opaque)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _opaque_pthread_rwlock_t {
pub __sig: ::std::os::raw::c_long,
pub __opaque: [::std::os::raw::c_char; 192usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_rwlock_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_rwlock_t>(),
200usize,
concat!("Size of: ", stringify!(_opaque_pthread_rwlock_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_rwlock_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_rwlock_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_rwlock_t>())).__sig as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_rwlock_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_rwlock_t>())).__opaque as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_rwlock_t),
"::",
stringify!(__opaque)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _opaque_pthread_rwlockattr_t {
pub __sig: ::std::os::raw::c_long,
pub __opaque: [::std::os::raw::c_char; 16usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_rwlockattr_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_rwlockattr_t>(),
24usize,
concat!("Size of: ", stringify!(_opaque_pthread_rwlockattr_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_rwlockattr_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_rwlockattr_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_rwlockattr_t>())).__sig as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_rwlockattr_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_rwlockattr_t>())).__opaque as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_rwlockattr_t),
"::",
stringify!(__opaque)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _opaque_pthread_t {
pub __sig: ::std::os::raw::c_long,
pub __cleanup_stack: *mut __darwin_pthread_handler_rec,
pub __opaque: [::std::os::raw::c_char; 8176usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_t>(),
8192usize,
concat!("Size of: ", stringify!(_opaque_pthread_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_t>())).__sig as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_t>())).__cleanup_stack as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_t),
"::",
stringify!(__cleanup_stack)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_t>())).__opaque as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_t),
"::",
stringify!(__opaque)
)
);
}
pub type __darwin_pthread_attr_t = _opaque_pthread_attr_t;
pub type __darwin_pthread_cond_t = _opaque_pthread_cond_t;
pub type __darwin_pthread_condattr_t = _opaque_pthread_condattr_t;
pub type __darwin_pthread_key_t = ::std::os::raw::c_ulong;
pub type __darwin_pthread_mutex_t = _opaque_pthread_mutex_t;
pub type __darwin_pthread_mutexattr_t = _opaque_pthread_mutexattr_t;
pub type __darwin_pthread_once_t = _opaque_pthread_once_t;
pub type __darwin_pthread_rwlock_t = _opaque_pthread_rwlock_t;
pub type __darwin_pthread_rwlockattr_t = _opaque_pthread_rwlockattr_t;
pub type __darwin_pthread_t = *mut _opaque_pthread_t;
pub type u_int8_t = ::std::os::raw::c_uchar;
pub type u_int16_t = ::std::os::raw::c_ushort;
pub type u_int32_t = ::std::os::raw::c_uint;
pub type u_int64_t = ::std::os::raw::c_ulonglong;
pub type register_t = i64;
pub type user_addr_t = u_int64_t;
pub type user_size_t = u_int64_t;
pub type user_ssize_t = i64;
pub type user_long_t = i64;
pub type user_ulong_t = u_int64_t;
pub type user_time_t = i64;
pub type user_off_t = i64;
pub type syscall_arg_t = u_int64_t;
pub type intmax_t = ::std::os::raw::c_long;
pub type uintmax_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_Device {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_Texture {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_Buffer {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_Renderbuffer {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_Effect {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_Query {
_unused: [u8; 0],
}
pub const FNA3D_PresentInterval_FNA3D_PRESENTINTERVAL_DEFAULT: FNA3D_PresentInterval = 0;
pub const FNA3D_PresentInterval_FNA3D_PRESENTINTERVAL_ONE: FNA3D_PresentInterval = 1;
pub const FNA3D_PresentInterval_FNA3D_PRESENTINTERVAL_TWO: FNA3D_PresentInterval = 2;
pub const FNA3D_PresentInterval_FNA3D_PRESENTINTERVAL_IMMEDIATE: FNA3D_PresentInterval = 3;
pub type FNA3D_PresentInterval = ::std::os::raw::c_uint;
pub const FNA3D_DisplayOrientation_FNA3D_DISPLAYORIENTATION_DEFAULT: FNA3D_DisplayOrientation = 0;
pub const FNA3D_DisplayOrientation_FNA3D_DISPLAYORIENTATION_LANDSCAPELEFT:
FNA3D_DisplayOrientation = 1;
pub const FNA3D_DisplayOrientation_FNA3D_DISPLAYORIENTATION_LANDSCAPERIGHT:
FNA3D_DisplayOrientation = 2;
pub const FNA3D_DisplayOrientation_FNA3D_DISPLAYORIENTATION_PORTRAIT: FNA3D_DisplayOrientation = 3;
pub type FNA3D_DisplayOrientation = ::std::os::raw::c_uint;
pub const FNA3D_RenderTargetUsage_FNA3D_RENDERTARGETUSAGE_DISCARDCONTENTS: FNA3D_RenderTargetUsage =
0;
pub const FNA3D_RenderTargetUsage_FNA3D_RENDERTARGETUSAGE_PRESERVECONTENTS:
FNA3D_RenderTargetUsage = 1;
pub const FNA3D_RenderTargetUsage_FNA3D_RENDERTARGETUSAGE_PLATFORMCONTENTS:
FNA3D_RenderTargetUsage = 2;
pub type FNA3D_RenderTargetUsage = ::std::os::raw::c_uint;
pub const FNA3D_ClearOptions_FNA3D_CLEAROPTIONS_TARGET: FNA3D_ClearOptions = 1;
pub const FNA3D_ClearOptions_FNA3D_CLEAROPTIONS_DEPTHBUFFER: FNA3D_ClearOptions = 2;
pub const FNA3D_ClearOptions_FNA3D_CLEAROPTIONS_STENCIL: FNA3D_ClearOptions = 4;
pub type FNA3D_ClearOptions = ::std::os::raw::c_uint;
pub const FNA3D_PrimitiveType_FNA3D_PRIMITIVETYPE_TRIANGLELIST: FNA3D_PrimitiveType = 0;
pub const FNA3D_PrimitiveType_FNA3D_PRIMITIVETYPE_TRIANGLESTRIP: FNA3D_PrimitiveType = 1;
pub const FNA3D_PrimitiveType_FNA3D_PRIMITIVETYPE_LINELIST: FNA3D_PrimitiveType = 2;
pub const FNA3D_PrimitiveType_FNA3D_PRIMITIVETYPE_LINESTRIP: FNA3D_PrimitiveType = 3;
pub const FNA3D_PrimitiveType_FNA3D_PRIMITIVETYPE_POINTLIST_EXT: FNA3D_PrimitiveType = 4;
pub type FNA3D_PrimitiveType = ::std::os::raw::c_uint;
pub const FNA3D_IndexElementSize_FNA3D_INDEXELEMENTSIZE_16BIT: FNA3D_IndexElementSize = 0;
pub const FNA3D_IndexElementSize_FNA3D_INDEXELEMENTSIZE_32BIT: FNA3D_IndexElementSize = 1;
pub type FNA3D_IndexElementSize = ::std::os::raw::c_uint;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_COLOR: FNA3D_SurfaceFormat = 0;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_BGR565: FNA3D_SurfaceFormat = 1;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_BGRA5551: FNA3D_SurfaceFormat = 2;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_BGRA4444: FNA3D_SurfaceFormat = 3;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_DXT1: FNA3D_SurfaceFormat = 4;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_DXT3: FNA3D_SurfaceFormat = 5;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_DXT5: FNA3D_SurfaceFormat = 6;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_NORMALIZEDBYTE2: FNA3D_SurfaceFormat = 7;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_NORMALIZEDBYTE4: FNA3D_SurfaceFormat = 8;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_RGBA1010102: FNA3D_SurfaceFormat = 9;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_RG32: FNA3D_SurfaceFormat = 10;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_RGBA64: FNA3D_SurfaceFormat = 11;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_ALPHA8: FNA3D_SurfaceFormat = 12;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_SINGLE: FNA3D_SurfaceFormat = 13;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_VECTOR2: FNA3D_SurfaceFormat = 14;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_VECTOR4: FNA3D_SurfaceFormat = 15;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_HALFSINGLE: FNA3D_SurfaceFormat = 16;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_HALFVECTOR2: FNA3D_SurfaceFormat = 17;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_HALFVECTOR4: FNA3D_SurfaceFormat = 18;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_HDRBLENDABLE: FNA3D_SurfaceFormat = 19;
pub const FNA3D_SurfaceFormat_FNA3D_SURFACEFORMAT_COLORBGRA_EXT: FNA3D_SurfaceFormat = 20;
pub type FNA3D_SurfaceFormat = ::std::os::raw::c_uint;
pub const FNA3D_DepthFormat_FNA3D_DEPTHFORMAT_NONE: FNA3D_DepthFormat = 0;
pub const FNA3D_DepthFormat_FNA3D_DEPTHFORMAT_D16: FNA3D_DepthFormat = 1;
pub const FNA3D_DepthFormat_FNA3D_DEPTHFORMAT_D24: FNA3D_DepthFormat = 2;
pub const FNA3D_DepthFormat_FNA3D_DEPTHFORMAT_D24S8: FNA3D_DepthFormat = 3;
pub type FNA3D_DepthFormat = ::std::os::raw::c_uint;
pub const FNA3D_CubeMapFace_FNA3D_CUBEMAPFACE_POSITIVEX: FNA3D_CubeMapFace = 0;
pub const FNA3D_CubeMapFace_FNA3D_CUBEMAPFACE_NEGATIVEX: FNA3D_CubeMapFace = 1;
pub const FNA3D_CubeMapFace_FNA3D_CUBEMAPFACE_POSITIVEY: FNA3D_CubeMapFace = 2;
pub const FNA3D_CubeMapFace_FNA3D_CUBEMAPFACE_NEGATIVEY: FNA3D_CubeMapFace = 3;
pub const FNA3D_CubeMapFace_FNA3D_CUBEMAPFACE_POSITIVEZ: FNA3D_CubeMapFace = 4;
pub const FNA3D_CubeMapFace_FNA3D_CUBEMAPFACE_NEGATIVEZ: FNA3D_CubeMapFace = 5;
pub type FNA3D_CubeMapFace = ::std::os::raw::c_uint;
pub const FNA3D_BufferUsage_FNA3D_BUFFERUSAGE_NONE: FNA3D_BufferUsage = 0;
pub const FNA3D_BufferUsage_FNA3D_BUFFERUSAGE_WRITEONLY: FNA3D_BufferUsage = 1;
pub type FNA3D_BufferUsage = ::std::os::raw::c_uint;
pub const FNA3D_SetDataOptions_FNA3D_SETDATAOPTIONS_NONE: FNA3D_SetDataOptions = 0;
pub const FNA3D_SetDataOptions_FNA3D_SETDATAOPTIONS_DISCARD: FNA3D_SetDataOptions = 1;
pub const FNA3D_SetDataOptions_FNA3D_SETDATAOPTIONS_NOOVERWRITE: FNA3D_SetDataOptions = 2;
pub type FNA3D_SetDataOptions = ::std::os::raw::c_uint;
pub const FNA3D_Blend_FNA3D_BLEND_ONE: FNA3D_Blend = 0;
pub const FNA3D_Blend_FNA3D_BLEND_ZERO: FNA3D_Blend = 1;
pub const FNA3D_Blend_FNA3D_BLEND_SOURCECOLOR: FNA3D_Blend = 2;
pub const FNA3D_Blend_FNA3D_BLEND_INVERSESOURCECOLOR: FNA3D_Blend = 3;
pub const FNA3D_Blend_FNA3D_BLEND_SOURCEALPHA: FNA3D_Blend = 4;
pub const FNA3D_Blend_FNA3D_BLEND_INVERSESOURCEALPHA: FNA3D_Blend = 5;
pub const FNA3D_Blend_FNA3D_BLEND_DESTINATIONCOLOR: FNA3D_Blend = 6;
pub const FNA3D_Blend_FNA3D_BLEND_INVERSEDESTINATIONCOLOR: FNA3D_Blend = 7;
pub const FNA3D_Blend_FNA3D_BLEND_DESTINATIONALPHA: FNA3D_Blend = 8;
pub const FNA3D_Blend_FNA3D_BLEND_INVERSEDESTINATIONALPHA: FNA3D_Blend = 9;
pub const FNA3D_Blend_FNA3D_BLEND_BLENDFACTOR: FNA3D_Blend = 10;
pub const FNA3D_Blend_FNA3D_BLEND_INVERSEBLENDFACTOR: FNA3D_Blend = 11;
pub const FNA3D_Blend_FNA3D_BLEND_SOURCEALPHASATURATION: FNA3D_Blend = 12;
pub type FNA3D_Blend = ::std::os::raw::c_uint;
pub const FNA3D_BlendFunction_FNA3D_BLENDFUNCTION_ADD: FNA3D_BlendFunction = 0;
pub const FNA3D_BlendFunction_FNA3D_BLENDFUNCTION_SUBTRACT: FNA3D_BlendFunction = 1;
pub const FNA3D_BlendFunction_FNA3D_BLENDFUNCTION_REVERSESUBTRACT: FNA3D_BlendFunction = 2;
pub const FNA3D_BlendFunction_FNA3D_BLENDFUNCTION_MAX: FNA3D_BlendFunction = 3;
pub const FNA3D_BlendFunction_FNA3D_BLENDFUNCTION_MIN: FNA3D_BlendFunction = 4;
pub type FNA3D_BlendFunction = ::std::os::raw::c_uint;
pub const FNA3D_ColorWriteChannels_FNA3D_COLORWRITECHANNELS_NONE: FNA3D_ColorWriteChannels = 0;
pub const FNA3D_ColorWriteChannels_FNA3D_COLORWRITECHANNELS_RED: FNA3D_ColorWriteChannels = 1;
pub const FNA3D_ColorWriteChannels_FNA3D_COLORWRITECHANNELS_GREEN: FNA3D_ColorWriteChannels = 2;
pub const FNA3D_ColorWriteChannels_FNA3D_COLORWRITECHANNELS_BLUE: FNA3D_ColorWriteChannels = 4;
pub const FNA3D_ColorWriteChannels_FNA3D_COLORWRITECHANNELS_ALPHA: FNA3D_ColorWriteChannels = 8;
pub const FNA3D_ColorWriteChannels_FNA3D_COLORWRITECHANNELS_ALL: FNA3D_ColorWriteChannels = 15;
pub type FNA3D_ColorWriteChannels = ::std::os::raw::c_uint;
pub const FNA3D_StencilOperation_FNA3D_STENCILOPERATION_KEEP: FNA3D_StencilOperation = 0;
pub const FNA3D_StencilOperation_FNA3D_STENCILOPERATION_ZERO: FNA3D_StencilOperation = 1;
pub const FNA3D_StencilOperation_FNA3D_STENCILOPERATION_REPLACE: FNA3D_StencilOperation = 2;
pub const FNA3D_StencilOperation_FNA3D_STENCILOPERATION_INCREMENT: FNA3D_StencilOperation = 3;
pub const FNA3D_StencilOperation_FNA3D_STENCILOPERATION_DECREMENT: FNA3D_StencilOperation = 4;
pub const FNA3D_StencilOperation_FNA3D_STENCILOPERATION_INCREMENTSATURATION:
FNA3D_StencilOperation = 5;
pub const FNA3D_StencilOperation_FNA3D_STENCILOPERATION_DECREMENTSATURATION:
FNA3D_StencilOperation = 6;
pub const FNA3D_StencilOperation_FNA3D_STENCILOPERATION_INVERT: FNA3D_StencilOperation = 7;
pub type FNA3D_StencilOperation = ::std::os::raw::c_uint;
pub const FNA3D_CompareFunction_FNA3D_COMPAREFUNCTION_ALWAYS: FNA3D_CompareFunction = 0;
pub const FNA3D_CompareFunction_FNA3D_COMPAREFUNCTION_NEVER: FNA3D_CompareFunction = 1;
pub const FNA3D_CompareFunction_FNA3D_COMPAREFUNCTION_LESS: FNA3D_CompareFunction = 2;
pub const FNA3D_CompareFunction_FNA3D_COMPAREFUNCTION_LESSEQUAL: FNA3D_CompareFunction = 3;
pub const FNA3D_CompareFunction_FNA3D_COMPAREFUNCTION_EQUAL: FNA3D_CompareFunction = 4;
pub const FNA3D_CompareFunction_FNA3D_COMPAREFUNCTION_GREATEREQUAL: FNA3D_CompareFunction = 5;
pub const FNA3D_CompareFunction_FNA3D_COMPAREFUNCTION_GREATER: FNA3D_CompareFunction = 6;
pub const FNA3D_CompareFunction_FNA3D_COMPAREFUNCTION_NOTEQUAL: FNA3D_CompareFunction = 7;
pub type FNA3D_CompareFunction = ::std::os::raw::c_uint;
pub const FNA3D_CullMode_FNA3D_CULLMODE_NONE: FNA3D_CullMode = 0;
pub const FNA3D_CullMode_FNA3D_CULLMODE_CULLCLOCKWISEFACE: FNA3D_CullMode = 1;
pub const FNA3D_CullMode_FNA3D_CULLMODE_CULLCOUNTERCLOCKWISEFACE: FNA3D_CullMode = 2;
pub type FNA3D_CullMode = ::std::os::raw::c_uint;
pub const FNA3D_FillMode_FNA3D_FILLMODE_SOLID: FNA3D_FillMode = 0;
pub const FNA3D_FillMode_FNA3D_FILLMODE_WIREFRAME: FNA3D_FillMode = 1;
pub type FNA3D_FillMode = ::std::os::raw::c_uint;
pub const FNA3D_TextureAddressMode_FNA3D_TEXTUREADDRESSMODE_WRAP: FNA3D_TextureAddressMode = 0;
pub const FNA3D_TextureAddressMode_FNA3D_TEXTUREADDRESSMODE_CLAMP: FNA3D_TextureAddressMode = 1;
pub const FNA3D_TextureAddressMode_FNA3D_TEXTUREADDRESSMODE_MIRROR: FNA3D_TextureAddressMode = 2;
pub type FNA3D_TextureAddressMode = ::std::os::raw::c_uint;
pub const FNA3D_TextureFilter_FNA3D_TEXTUREFILTER_LINEAR: FNA3D_TextureFilter = 0;
pub const FNA3D_TextureFilter_FNA3D_TEXTUREFILTER_POINT: FNA3D_TextureFilter = 1;
pub const FNA3D_TextureFilter_FNA3D_TEXTUREFILTER_ANISOTROPIC: FNA3D_TextureFilter = 2;
pub const FNA3D_TextureFilter_FNA3D_TEXTUREFILTER_LINEAR_MIPPOINT: FNA3D_TextureFilter = 3;
pub const FNA3D_TextureFilter_FNA3D_TEXTUREFILTER_POINT_MIPLINEAR: FNA3D_TextureFilter = 4;
pub const FNA3D_TextureFilter_FNA3D_TEXTUREFILTER_MINLINEAR_MAGPOINT_MIPLINEAR:
FNA3D_TextureFilter = 5;
pub const FNA3D_TextureFilter_FNA3D_TEXTUREFILTER_MINLINEAR_MAGPOINT_MIPPOINT: FNA3D_TextureFilter =
6;
pub const FNA3D_TextureFilter_FNA3D_TEXTUREFILTER_MINPOINT_MAGLINEAR_MIPLINEAR:
FNA3D_TextureFilter = 7;
pub const FNA3D_TextureFilter_FNA3D_TEXTUREFILTER_MINPOINT_MAGLINEAR_MIPPOINT: FNA3D_TextureFilter =
8;
pub type FNA3D_TextureFilter = ::std::os::raw::c_uint;
pub const FNA3D_VertexElementFormat_FNA3D_VERTEXELEMENTFORMAT_SINGLE: FNA3D_VertexElementFormat = 0;
pub const FNA3D_VertexElementFormat_FNA3D_VERTEXELEMENTFORMAT_VECTOR2: FNA3D_VertexElementFormat =
1;
pub const FNA3D_VertexElementFormat_FNA3D_VERTEXELEMENTFORMAT_VECTOR3: FNA3D_VertexElementFormat =
2;
pub const FNA3D_VertexElementFormat_FNA3D_VERTEXELEMENTFORMAT_VECTOR4: FNA3D_VertexElementFormat =
3;
pub const FNA3D_VertexElementFormat_FNA3D_VERTEXELEMENTFORMAT_COLOR: FNA3D_VertexElementFormat = 4;
pub const FNA3D_VertexElementFormat_FNA3D_VERTEXELEMENTFORMAT_BYTE4: FNA3D_VertexElementFormat = 5;
pub const FNA3D_VertexElementFormat_FNA3D_VERTEXELEMENTFORMAT_SHORT2: FNA3D_VertexElementFormat = 6;
pub const FNA3D_VertexElementFormat_FNA3D_VERTEXELEMENTFORMAT_SHORT4: FNA3D_VertexElementFormat = 7;
pub const FNA3D_VertexElementFormat_FNA3D_VERTEXELEMENTFORMAT_NORMALIZEDSHORT2:
FNA3D_VertexElementFormat = 8;
pub const FNA3D_VertexElementFormat_FNA3D_VERTEXELEMENTFORMAT_NORMALIZEDSHORT4:
FNA3D_VertexElementFormat = 9;
pub const FNA3D_VertexElementFormat_FNA3D_VERTEXELEMENTFORMAT_HALFVECTOR2:
FNA3D_VertexElementFormat = 10;
pub const FNA3D_VertexElementFormat_FNA3D_VERTEXELEMENTFORMAT_HALFVECTOR4:
FNA3D_VertexElementFormat = 11;
pub type FNA3D_VertexElementFormat = ::std::os::raw::c_uint;
pub const FNA3D_VertexElementUsage_FNA3D_VERTEXELEMENTUSAGE_POSITION: FNA3D_VertexElementUsage = 0;
pub const FNA3D_VertexElementUsage_FNA3D_VERTEXELEMENTUSAGE_COLOR: FNA3D_VertexElementUsage = 1;
pub const FNA3D_VertexElementUsage_FNA3D_VERTEXELEMENTUSAGE_TEXTURECOORDINATE:
FNA3D_VertexElementUsage = 2;
pub const FNA3D_VertexElementUsage_FNA3D_VERTEXELEMENTUSAGE_NORMAL: FNA3D_VertexElementUsage = 3;
pub const FNA3D_VertexElementUsage_FNA3D_VERTEXELEMENTUSAGE_BINORMAL: FNA3D_VertexElementUsage = 4;
pub const FNA3D_VertexElementUsage_FNA3D_VERTEXELEMENTUSAGE_TANGENT: FNA3D_VertexElementUsage = 5;
pub const FNA3D_VertexElementUsage_FNA3D_VERTEXELEMENTUSAGE_BLENDINDICES: FNA3D_VertexElementUsage =
6;
pub const FNA3D_VertexElementUsage_FNA3D_VERTEXELEMENTUSAGE_BLENDWEIGHT: FNA3D_VertexElementUsage =
7;
pub const FNA3D_VertexElementUsage_FNA3D_VERTEXELEMENTUSAGE_DEPTH: FNA3D_VertexElementUsage = 8;
pub const FNA3D_VertexElementUsage_FNA3D_VERTEXELEMENTUSAGE_FOG: FNA3D_VertexElementUsage = 9;
pub const FNA3D_VertexElementUsage_FNA3D_VERTEXELEMENTUSAGE_POINTSIZE: FNA3D_VertexElementUsage =
10;
pub const FNA3D_VertexElementUsage_FNA3D_VERTEXELEMENTUSAGE_SAMPLE: FNA3D_VertexElementUsage = 11;
pub const FNA3D_VertexElementUsage_FNA3D_VERTEXELEMENTUSAGE_TESSELATEFACTOR:
FNA3D_VertexElementUsage = 12;
pub type FNA3D_VertexElementUsage = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_Color {
pub r: u8,
pub g: u8,
pub b: u8,
pub a: u8,
}
#[test]
fn bindgen_test_layout_FNA3D_Color() {
assert_eq!(
::std::mem::size_of::<FNA3D_Color>(),
4usize,
concat!("Size of: ", stringify!(FNA3D_Color))
);
assert_eq!(
::std::mem::align_of::<FNA3D_Color>(),
1usize,
concat!("Alignment of ", stringify!(FNA3D_Color))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Color>())).r as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Color),
"::",
stringify!(r)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Color>())).g as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Color),
"::",
stringify!(g)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Color>())).b as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Color),
"::",
stringify!(b)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Color>())).a as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Color),
"::",
stringify!(a)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_Rect {
pub x: i32,
pub y: i32,
pub w: i32,
pub h: i32,
}
#[test]
fn bindgen_test_layout_FNA3D_Rect() {
assert_eq!(
::std::mem::size_of::<FNA3D_Rect>(),
16usize,
concat!("Size of: ", stringify!(FNA3D_Rect))
);
assert_eq!(
::std::mem::align_of::<FNA3D_Rect>(),
4usize,
concat!("Alignment of ", stringify!(FNA3D_Rect))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Rect>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Rect),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Rect>())).y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Rect),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Rect>())).w as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Rect),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Rect>())).h as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Rect),
"::",
stringify!(h)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_Vec4 {
pub x: f32,
pub y: f32,
pub z: f32,
pub w: f32,
}
#[test]
fn bindgen_test_layout_FNA3D_Vec4() {
assert_eq!(
::std::mem::size_of::<FNA3D_Vec4>(),
16usize,
concat!("Size of: ", stringify!(FNA3D_Vec4))
);
assert_eq!(
::std::mem::align_of::<FNA3D_Vec4>(),
4usize,
concat!("Alignment of ", stringify!(FNA3D_Vec4))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Vec4>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Vec4),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Vec4>())).y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Vec4),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Vec4>())).z as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Vec4),
"::",
stringify!(z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Vec4>())).w as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Vec4),
"::",
stringify!(w)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_Viewport {
pub x: i32,
pub y: i32,
pub w: i32,
pub h: i32,
pub minDepth: f32,
pub maxDepth: f32,
}
#[test]
fn bindgen_test_layout_FNA3D_Viewport() {
assert_eq!(
::std::mem::size_of::<FNA3D_Viewport>(),
24usize,
concat!("Size of: ", stringify!(FNA3D_Viewport))
);
assert_eq!(
::std::mem::align_of::<FNA3D_Viewport>(),
4usize,
concat!("Alignment of ", stringify!(FNA3D_Viewport))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Viewport>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Viewport),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Viewport>())).y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Viewport),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Viewport>())).w as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Viewport),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Viewport>())).h as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Viewport),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Viewport>())).minDepth as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Viewport),
"::",
stringify!(minDepth)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_Viewport>())).maxDepth as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_Viewport),
"::",
stringify!(maxDepth)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_PresentationParameters {
pub backBufferWidth: i32,
pub backBufferHeight: i32,
pub backBufferFormat: FNA3D_SurfaceFormat,
pub multiSampleCount: i32,
pub deviceWindowHandle: *mut ::std::os::raw::c_void,
pub isFullScreen: u8,
pub depthStencilFormat: FNA3D_DepthFormat,
pub presentationInterval: FNA3D_PresentInterval,
pub displayOrientation: FNA3D_DisplayOrientation,
pub renderTargetUsage: FNA3D_RenderTargetUsage,
}
#[test]
fn bindgen_test_layout_FNA3D_PresentationParameters() {
assert_eq!(
::std::mem::size_of::<FNA3D_PresentationParameters>(),
48usize,
concat!("Size of: ", stringify!(FNA3D_PresentationParameters))
);
assert_eq!(
::std::mem::align_of::<FNA3D_PresentationParameters>(),
8usize,
concat!("Alignment of ", stringify!(FNA3D_PresentationParameters))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_PresentationParameters>())).backBufferWidth as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_PresentationParameters),
"::",
stringify!(backBufferWidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_PresentationParameters>())).backBufferHeight as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_PresentationParameters),
"::",
stringify!(backBufferHeight)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_PresentationParameters>())).backBufferFormat as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_PresentationParameters),
"::",
stringify!(backBufferFormat)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_PresentationParameters>())).multiSampleCount as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_PresentationParameters),
"::",
stringify!(multiSampleCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_PresentationParameters>())).deviceWindowHandle as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_PresentationParameters),
"::",
stringify!(deviceWindowHandle)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_PresentationParameters>())).isFullScreen as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_PresentationParameters),
"::",
stringify!(isFullScreen)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_PresentationParameters>())).depthStencilFormat as *const _
as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_PresentationParameters),
"::",
stringify!(depthStencilFormat)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_PresentationParameters>())).presentationInterval
as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_PresentationParameters),
"::",
stringify!(presentationInterval)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_PresentationParameters>())).displayOrientation as *const _
as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_PresentationParameters),
"::",
stringify!(displayOrientation)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_PresentationParameters>())).renderTargetUsage as *const _
as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_PresentationParameters),
"::",
stringify!(renderTargetUsage)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_BlendState {
pub colorSourceBlend: FNA3D_Blend,
pub colorDestinationBlend: FNA3D_Blend,
pub colorBlendFunction: FNA3D_BlendFunction,
pub alphaSourceBlend: FNA3D_Blend,
pub alphaDestinationBlend: FNA3D_Blend,
pub alphaBlendFunction: FNA3D_BlendFunction,
pub colorWriteEnable: FNA3D_ColorWriteChannels,
pub colorWriteEnable1: FNA3D_ColorWriteChannels,
pub colorWriteEnable2: FNA3D_ColorWriteChannels,
pub colorWriteEnable3: FNA3D_ColorWriteChannels,
pub blendFactor: FNA3D_Color,
pub multiSampleMask: i32,
}
#[test]
fn bindgen_test_layout_FNA3D_BlendState() {
assert_eq!(
::std::mem::size_of::<FNA3D_BlendState>(),
48usize,
concat!("Size of: ", stringify!(FNA3D_BlendState))
);
assert_eq!(
::std::mem::align_of::<FNA3D_BlendState>(),
4usize,
concat!("Alignment of ", stringify!(FNA3D_BlendState))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_BlendState>())).colorSourceBlend as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_BlendState),
"::",
stringify!(colorSourceBlend)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_BlendState>())).colorDestinationBlend as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_BlendState),
"::",
stringify!(colorDestinationBlend)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_BlendState>())).colorBlendFunction as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_BlendState),
"::",
stringify!(colorBlendFunction)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_BlendState>())).alphaSourceBlend as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_BlendState),
"::",
stringify!(alphaSourceBlend)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_BlendState>())).alphaDestinationBlend as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_BlendState),
"::",
stringify!(alphaDestinationBlend)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_BlendState>())).alphaBlendFunction as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_BlendState),
"::",
stringify!(alphaBlendFunction)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_BlendState>())).colorWriteEnable as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_BlendState),
"::",
stringify!(colorWriteEnable)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_BlendState>())).colorWriteEnable1 as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_BlendState),
"::",
stringify!(colorWriteEnable1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_BlendState>())).colorWriteEnable2 as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_BlendState),
"::",
stringify!(colorWriteEnable2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_BlendState>())).colorWriteEnable3 as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_BlendState),
"::",
stringify!(colorWriteEnable3)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_BlendState>())).blendFactor as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_BlendState),
"::",
stringify!(blendFactor)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_BlendState>())).multiSampleMask as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_BlendState),
"::",
stringify!(multiSampleMask)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_DepthStencilState {
pub depthBufferEnable: u8,
pub depthBufferWriteEnable: u8,
pub depthBufferFunction: FNA3D_CompareFunction,
pub stencilEnable: u8,
pub stencilMask: i32,
pub stencilWriteMask: i32,
pub twoSidedStencilMode: u8,
pub stencilFail: FNA3D_StencilOperation,
pub stencilDepthBufferFail: FNA3D_StencilOperation,
pub stencilPass: FNA3D_StencilOperation,
pub stencilFunction: FNA3D_CompareFunction,
pub ccwStencilFail: FNA3D_StencilOperation,
pub ccwStencilDepthBufferFail: FNA3D_StencilOperation,
pub ccwStencilPass: FNA3D_StencilOperation,
pub ccwStencilFunction: FNA3D_CompareFunction,
pub referenceStencil: i32,
}
#[test]
fn bindgen_test_layout_FNA3D_DepthStencilState() {
assert_eq!(
::std::mem::size_of::<FNA3D_DepthStencilState>(),
60usize,
concat!("Size of: ", stringify!(FNA3D_DepthStencilState))
);
assert_eq!(
::std::mem::align_of::<FNA3D_DepthStencilState>(),
4usize,
concat!("Alignment of ", stringify!(FNA3D_DepthStencilState))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_DepthStencilState>())).depthBufferEnable as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_DepthStencilState),
"::",
stringify!(depthBufferEnable)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_DepthStencilState>())).depthBufferWriteEnable as *const _
as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_DepthStencilState),
"::",
stringify!(depthBufferWriteEnable)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_DepthStencilState>())).depthBufferFunction as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_DepthStencilState),
"::",
stringify!(depthBufferFunction)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_DepthStencilState>())).stencilEnable as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_DepthStencilState),
"::",
stringify!(stencilEnable)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_DepthStencilState>())).stencilMask as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_DepthStencilState),
"::",
stringify!(stencilMask)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_DepthStencilState>())).stencilWriteMask as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_DepthStencilState),
"::",
stringify!(stencilWriteMask)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_DepthStencilState>())).twoSidedStencilMode as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_DepthStencilState),
"::",
stringify!(twoSidedStencilMode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_DepthStencilState>())).stencilFail as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_DepthStencilState),
"::",
stringify!(stencilFail)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_DepthStencilState>())).stencilDepthBufferFail as *const _
as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_DepthStencilState),
"::",
stringify!(stencilDepthBufferFail)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_DepthStencilState>())).stencilPass as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_DepthStencilState),
"::",
stringify!(stencilPass)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_DepthStencilState>())).stencilFunction as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_DepthStencilState),
"::",
stringify!(stencilFunction)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_DepthStencilState>())).ccwStencilFail as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_DepthStencilState),
"::",
stringify!(ccwStencilFail)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_DepthStencilState>())).ccwStencilDepthBufferFail
as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_DepthStencilState),
"::",
stringify!(ccwStencilDepthBufferFail)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_DepthStencilState>())).ccwStencilPass as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_DepthStencilState),
"::",
stringify!(ccwStencilPass)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_DepthStencilState>())).ccwStencilFunction as *const _
as usize
},
52usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_DepthStencilState),
"::",
stringify!(ccwStencilFunction)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_DepthStencilState>())).referenceStencil as *const _
as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_DepthStencilState),
"::",
stringify!(referenceStencil)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_RasterizerState {
pub fillMode: FNA3D_FillMode,
pub cullMode: FNA3D_CullMode,
pub depthBias: f32,
pub slopeScaleDepthBias: f32,
pub scissorTestEnable: u8,
pub multiSampleAntiAlias: u8,
}
#[test]
fn bindgen_test_layout_FNA3D_RasterizerState() {
assert_eq!(
::std::mem::size_of::<FNA3D_RasterizerState>(),
20usize,
concat!("Size of: ", stringify!(FNA3D_RasterizerState))
);
assert_eq!(
::std::mem::align_of::<FNA3D_RasterizerState>(),
4usize,
concat!("Alignment of ", stringify!(FNA3D_RasterizerState))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_RasterizerState>())).fillMode as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RasterizerState),
"::",
stringify!(fillMode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_RasterizerState>())).cullMode as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RasterizerState),
"::",
stringify!(cullMode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_RasterizerState>())).depthBias as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RasterizerState),
"::",
stringify!(depthBias)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_RasterizerState>())).slopeScaleDepthBias as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RasterizerState),
"::",
stringify!(slopeScaleDepthBias)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_RasterizerState>())).scissorTestEnable as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RasterizerState),
"::",
stringify!(scissorTestEnable)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_RasterizerState>())).multiSampleAntiAlias as *const _
as usize
},
17usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RasterizerState),
"::",
stringify!(multiSampleAntiAlias)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_SamplerState {
pub filter: FNA3D_TextureFilter,
pub addressU: FNA3D_TextureAddressMode,
pub addressV: FNA3D_TextureAddressMode,
pub addressW: FNA3D_TextureAddressMode,
pub mipMapLevelOfDetailBias: f32,
pub maxAnisotropy: i32,
pub maxMipLevel: i32,
}
#[test]
fn bindgen_test_layout_FNA3D_SamplerState() {
assert_eq!(
::std::mem::size_of::<FNA3D_SamplerState>(),
28usize,
concat!("Size of: ", stringify!(FNA3D_SamplerState))
);
assert_eq!(
::std::mem::align_of::<FNA3D_SamplerState>(),
4usize,
concat!("Alignment of ", stringify!(FNA3D_SamplerState))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_SamplerState>())).filter as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_SamplerState),
"::",
stringify!(filter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_SamplerState>())).addressU as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_SamplerState),
"::",
stringify!(addressU)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_SamplerState>())).addressV as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_SamplerState),
"::",
stringify!(addressV)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_SamplerState>())).addressW as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_SamplerState),
"::",
stringify!(addressW)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_SamplerState>())).mipMapLevelOfDetailBias as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_SamplerState),
"::",
stringify!(mipMapLevelOfDetailBias)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_SamplerState>())).maxAnisotropy as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_SamplerState),
"::",
stringify!(maxAnisotropy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_SamplerState>())).maxMipLevel as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_SamplerState),
"::",
stringify!(maxMipLevel)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_VertexElement {
pub offset: i32,
pub vertexElementFormat: FNA3D_VertexElementFormat,
pub vertexElementUsage: FNA3D_VertexElementUsage,
pub usageIndex: i32,
}
#[test]
fn bindgen_test_layout_FNA3D_VertexElement() {
assert_eq!(
::std::mem::size_of::<FNA3D_VertexElement>(),
16usize,
concat!("Size of: ", stringify!(FNA3D_VertexElement))
);
assert_eq!(
::std::mem::align_of::<FNA3D_VertexElement>(),
4usize,
concat!("Alignment of ", stringify!(FNA3D_VertexElement))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_VertexElement>())).offset as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_VertexElement),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_VertexElement>())).vertexElementFormat as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_VertexElement),
"::",
stringify!(vertexElementFormat)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_VertexElement>())).vertexElementUsage as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_VertexElement),
"::",
stringify!(vertexElementUsage)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_VertexElement>())).usageIndex as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_VertexElement),
"::",
stringify!(usageIndex)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_VertexDeclaration {
pub vertexStride: i32,
pub elementCount: i32,
pub elements: *mut FNA3D_VertexElement,
}
#[test]
fn bindgen_test_layout_FNA3D_VertexDeclaration() {
assert_eq!(
::std::mem::size_of::<FNA3D_VertexDeclaration>(),
16usize,
concat!("Size of: ", stringify!(FNA3D_VertexDeclaration))
);
assert_eq!(
::std::mem::align_of::<FNA3D_VertexDeclaration>(),
8usize,
concat!("Alignment of ", stringify!(FNA3D_VertexDeclaration))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_VertexDeclaration>())).vertexStride as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_VertexDeclaration),
"::",
stringify!(vertexStride)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_VertexDeclaration>())).elementCount as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_VertexDeclaration),
"::",
stringify!(elementCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_VertexDeclaration>())).elements as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_VertexDeclaration),
"::",
stringify!(elements)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_VertexBufferBinding {
pub vertexBuffer: *mut FNA3D_Buffer,
pub vertexDeclaration: FNA3D_VertexDeclaration,
pub vertexOffset: i32,
pub instanceFrequency: i32,
}
#[test]
fn bindgen_test_layout_FNA3D_VertexBufferBinding() {
assert_eq!(
::std::mem::size_of::<FNA3D_VertexBufferBinding>(),
32usize,
concat!("Size of: ", stringify!(FNA3D_VertexBufferBinding))
);
assert_eq!(
::std::mem::align_of::<FNA3D_VertexBufferBinding>(),
8usize,
concat!("Alignment of ", stringify!(FNA3D_VertexBufferBinding))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_VertexBufferBinding>())).vertexBuffer as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_VertexBufferBinding),
"::",
stringify!(vertexBuffer)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_VertexBufferBinding>())).vertexDeclaration as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_VertexBufferBinding),
"::",
stringify!(vertexDeclaration)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_VertexBufferBinding>())).vertexOffset as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_VertexBufferBinding),
"::",
stringify!(vertexOffset)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_VertexBufferBinding>())).instanceFrequency as *const _
as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_VertexBufferBinding),
"::",
stringify!(instanceFrequency)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FNA3D_RenderTargetBinding {
pub type_: u8,
pub __bindgen_anon_1: FNA3D_RenderTargetBinding__bindgen_ty_1,
pub levelCount: i32,
pub multiSampleCount: i32,
pub texture: *mut FNA3D_Texture,
pub colorBuffer: *mut FNA3D_Renderbuffer,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union FNA3D_RenderTargetBinding__bindgen_ty_1 {
pub twod: FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_1,
pub cube: FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_2,
_bindgen_union_align: [u32; 2usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_1 {
pub width: i32,
pub height: i32,
}
#[test]
fn bindgen_test_layout_FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_1>())).width
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_1>())).height
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(height)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_2 {
pub size: i32,
pub face: FNA3D_CubeMapFace,
}
#[test]
fn bindgen_test_layout_FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_2>(),
8usize,
concat!(
"Size of: ",
stringify!(FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
::std::mem::align_of::<FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_2>(),
4usize,
concat!(
"Alignment of ",
stringify!(FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_2>())).size
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_2>())).face
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RenderTargetBinding__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(face)
)
);
}
#[test]
fn bindgen_test_layout_FNA3D_RenderTargetBinding__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<FNA3D_RenderTargetBinding__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(FNA3D_RenderTargetBinding__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<FNA3D_RenderTargetBinding__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(FNA3D_RenderTargetBinding__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_RenderTargetBinding__bindgen_ty_1>())).twod as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RenderTargetBinding__bindgen_ty_1),
"::",
stringify!(twod)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_RenderTargetBinding__bindgen_ty_1>())).cube as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RenderTargetBinding__bindgen_ty_1),
"::",
stringify!(cube)
)
);
}
#[test]
fn bindgen_test_layout_FNA3D_RenderTargetBinding() {
assert_eq!(
::std::mem::size_of::<FNA3D_RenderTargetBinding>(),
40usize,
concat!("Size of: ", stringify!(FNA3D_RenderTargetBinding))
);
assert_eq!(
::std::mem::align_of::<FNA3D_RenderTargetBinding>(),
8usize,
concat!("Alignment of ", stringify!(FNA3D_RenderTargetBinding))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FNA3D_RenderTargetBinding>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RenderTargetBinding),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_RenderTargetBinding>())).levelCount as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RenderTargetBinding),
"::",
stringify!(levelCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_RenderTargetBinding>())).multiSampleCount as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RenderTargetBinding),
"::",
stringify!(multiSampleCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_RenderTargetBinding>())).texture as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RenderTargetBinding),
"::",
stringify!(texture)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FNA3D_RenderTargetBinding>())).colorBuffer as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(FNA3D_RenderTargetBinding),
"::",
stringify!(colorBuffer)
)
);
}
extern "C" {
pub fn FNA3D_LinkedVersion() -> u32;
}
pub type FNA3D_LogFunc =
::std::option::Option<unsafe extern "C" fn(msg: *const ::std::os::raw::c_char)>;
extern "C" {
pub fn FNA3D_HookLogFunctions(info: FNA3D_LogFunc, warn: FNA3D_LogFunc, error: FNA3D_LogFunc);
}
extern "C" {
pub fn FNA3D_PrepareWindowAttributes() -> u32;
}
extern "C" {
pub fn FNA3D_GetDrawableSize(window: *mut ::std::os::raw::c_void, w: *mut i32, h: *mut i32);
}
extern "C" {
pub fn FNA3D_CreateDevice(
presentationParameters: *mut FNA3D_PresentationParameters,
debugMode: u8,
) -> *mut FNA3D_Device;
}
extern "C" {
pub fn FNA3D_DestroyDevice(device: *mut FNA3D_Device);
}
extern "C" {
pub fn FNA3D_SwapBuffers(
device: *mut FNA3D_Device,
sourceRectangle: *mut FNA3D_Rect,
destinationRectangle: *mut FNA3D_Rect,
overrideWindowHandle: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn FNA3D_Clear(
device: *mut FNA3D_Device,
options: FNA3D_ClearOptions,
color: *mut FNA3D_Vec4,
depth: f32,
stencil: i32,
);
}
extern "C" {
pub fn FNA3D_DrawIndexedPrimitives(
device: *mut FNA3D_Device,
primitiveType: FNA3D_PrimitiveType,
baseVertex: i32,
minVertexIndex: i32,
numVertices: i32,
startIndex: i32,
primitiveCount: i32,
indices: *mut FNA3D_Buffer,
indexElementSize: FNA3D_IndexElementSize,
);
}
extern "C" {
pub fn FNA3D_DrawInstancedPrimitives(
device: *mut FNA3D_Device,
primitiveType: FNA3D_PrimitiveType,
baseVertex: i32,
minVertexIndex: i32,
numVertices: i32,
startIndex: i32,
primitiveCount: i32,
instanceCount: i32,
indices: *mut FNA3D_Buffer,
indexElementSize: FNA3D_IndexElementSize,
);
}
extern "C" {
pub fn FNA3D_DrawPrimitives(
device: *mut FNA3D_Device,
primitiveType: FNA3D_PrimitiveType,
vertexStart: i32,
primitiveCount: i32,
);
}
extern "C" {
pub fn FNA3D_SetViewport(device: *mut FNA3D_Device, viewport: *mut FNA3D_Viewport);
}
extern "C" {
pub fn FNA3D_SetScissorRect(device: *mut FNA3D_Device, scissor: *mut FNA3D_Rect);
}
extern "C" {
pub fn FNA3D_GetBlendFactor(device: *mut FNA3D_Device, blendFactor: *mut FNA3D_Color);
}
extern "C" {
pub fn FNA3D_SetBlendFactor(device: *mut FNA3D_Device, blendFactor: *mut FNA3D_Color);
}
extern "C" {
pub fn FNA3D_GetMultiSampleMask(device: *mut FNA3D_Device) -> i32;
}
extern "C" {
pub fn FNA3D_SetMultiSampleMask(device: *mut FNA3D_Device, mask: i32);
}
extern "C" {
pub fn FNA3D_GetReferenceStencil(device: *mut FNA3D_Device) -> i32;
}
extern "C" {
pub fn FNA3D_SetReferenceStencil(device: *mut FNA3D_Device, ref_: i32);
}
extern "C" {
pub fn FNA3D_SetBlendState(device: *mut FNA3D_Device, blendState: *mut FNA3D_BlendState);
}
extern "C" {
pub fn FNA3D_SetDepthStencilState(
device: *mut FNA3D_Device,
depthStencilState: *mut FNA3D_DepthStencilState,
);
}
extern "C" {
pub fn FNA3D_ApplyRasterizerState(
device: *mut FNA3D_Device,
rasterizerState: *mut FNA3D_RasterizerState,
);
}
extern "C" {
pub fn FNA3D_VerifySampler(
device: *mut FNA3D_Device,
index: i32,
texture: *mut FNA3D_Texture,
sampler: *mut FNA3D_SamplerState,
);
}
extern "C" {
pub fn FNA3D_VerifyVertexSampler(
device: *mut FNA3D_Device,
index: i32,
texture: *mut FNA3D_Texture,
sampler: *mut FNA3D_SamplerState,
);
}
extern "C" {
pub fn FNA3D_ApplyVertexBufferBindings(
device: *mut FNA3D_Device,
bindings: *mut FNA3D_VertexBufferBinding,
numBindings: i32,
bindingsUpdated: u8,
baseVertex: i32,
);
}
extern "C" {
pub fn FNA3D_SetRenderTargets(
device: *mut FNA3D_Device,
renderTargets: *mut FNA3D_RenderTargetBinding,
numRenderTargets: i32,
depthStencilBuffer: *mut FNA3D_Renderbuffer,
depthFormat: FNA3D_DepthFormat,
preserveTargetContents: u8,
);
}
extern "C" {
pub fn FNA3D_ResolveTarget(device: *mut FNA3D_Device, target: *mut FNA3D_RenderTargetBinding);
}
extern "C" {
pub fn FNA3D_ResetBackbuffer(
device: *mut FNA3D_Device,
presentationParameters: *mut FNA3D_PresentationParameters,
);
}
extern "C" {
pub fn FNA3D_ReadBackbuffer(
device: *mut FNA3D_Device,
x: i32,
y: i32,
w: i32,
h: i32,
data: *mut ::std::os::raw::c_void,
dataLength: i32,
);
}
extern "C" {
pub fn FNA3D_GetBackbufferSize(device: *mut FNA3D_Device, w: *mut i32, h: *mut i32);
}
extern "C" {
pub fn FNA3D_GetBackbufferSurfaceFormat(device: *mut FNA3D_Device) -> FNA3D_SurfaceFormat;
}
extern "C" {
pub fn FNA3D_GetBackbufferDepthFormat(device: *mut FNA3D_Device) -> FNA3D_DepthFormat;
}
extern "C" {
pub fn FNA3D_GetBackbufferMultiSampleCount(device: *mut FNA3D_Device) -> i32;
}
extern "C" {
pub fn FNA3D_CreateTexture2D(
device: *mut FNA3D_Device,
format: FNA3D_SurfaceFormat,
width: i32,
height: i32,
levelCount: i32,
isRenderTarget: u8,
) -> *mut FNA3D_Texture;
}
extern "C" {
pub fn FNA3D_CreateTexture3D(
device: *mut FNA3D_Device,
format: FNA3D_SurfaceFormat,
width: i32,
height: i32,
depth: i32,
levelCount: i32,
) -> *mut FNA3D_Texture;
}
extern "C" {
pub fn FNA3D_CreateTextureCube(
device: *mut FNA3D_Device,
format: FNA3D_SurfaceFormat,
size: i32,
levelCount: i32,
isRenderTarget: u8,
) -> *mut FNA3D_Texture;
}
extern "C" {
pub fn FNA3D_AddDisposeTexture(device: *mut FNA3D_Device, texture: *mut FNA3D_Texture);
}
extern "C" {
pub fn FNA3D_SetTextureData2D(
device: *mut FNA3D_Device,
texture: *mut FNA3D_Texture,
x: i32,
y: i32,
w: i32,
h: i32,
level: i32,
data: *mut ::std::os::raw::c_void,
dataLength: i32,
);
}
extern "C" {
pub fn FNA3D_SetTextureData3D(
device: *mut FNA3D_Device,
texture: *mut FNA3D_Texture,
x: i32,
y: i32,
z: i32,
w: i32,
h: i32,
d: i32,
level: i32,
data: *mut ::std::os::raw::c_void,
dataLength: i32,
);
}
extern "C" {
pub fn FNA3D_SetTextureDataCube(
device: *mut FNA3D_Device,
texture: *mut FNA3D_Texture,
x: i32,
y: i32,
w: i32,
h: i32,
cubeMapFace: FNA3D_CubeMapFace,
level: i32,
data: *mut ::std::os::raw::c_void,
dataLength: i32,
);
}
extern "C" {
pub fn FNA3D_SetTextureDataYUV(
device: *mut FNA3D_Device,
y: *mut FNA3D_Texture,
u: *mut FNA3D_Texture,
v: *mut FNA3D_Texture,
yWidth: i32,
yHeight: i32,
uvWidth: i32,
uvHeight: i32,
data: *mut ::std::os::raw::c_void,
dataLength: i32,
);
}
extern "C" {
pub fn FNA3D_GetTextureData2D(
device: *mut FNA3D_Device,
texture: *mut FNA3D_Texture,
x: i32,
y: i32,
w: i32,
h: i32,
level: i32,
data: *mut ::std::os::raw::c_void,
dataLength: i32,
);
}
extern "C" {
pub fn FNA3D_GetTextureData3D(
device: *mut FNA3D_Device,
texture: *mut FNA3D_Texture,
x: i32,
y: i32,
z: i32,
w: i32,
h: i32,
d: i32,
level: i32,
data: *mut ::std::os::raw::c_void,
dataLength: i32,
);
}
extern "C" {
pub fn FNA3D_GetTextureDataCube(
device: *mut FNA3D_Device,
texture: *mut FNA3D_Texture,
x: i32,
y: i32,
w: i32,
h: i32,
cubeMapFace: FNA3D_CubeMapFace,
level: i32,
data: *mut ::std::os::raw::c_void,
dataLength: i32,
);
}
extern "C" {
pub fn FNA3D_GenColorRenderbuffer(
device: *mut FNA3D_Device,
width: i32,
height: i32,
format: FNA3D_SurfaceFormat,
multiSampleCount: i32,
texture: *mut FNA3D_Texture,
) -> *mut FNA3D_Renderbuffer;
}
extern "C" {
pub fn FNA3D_GenDepthStencilRenderbuffer(
device: *mut FNA3D_Device,
width: i32,
height: i32,
format: FNA3D_DepthFormat,
multiSampleCount: i32,
) -> *mut FNA3D_Renderbuffer;
}
extern "C" {
pub fn FNA3D_AddDisposeRenderbuffer(
device: *mut FNA3D_Device,
renderbuffer: *mut FNA3D_Renderbuffer,
);
}
extern "C" {
pub fn FNA3D_GenVertexBuffer(
device: *mut FNA3D_Device,
dynamic: u8,
usage: FNA3D_BufferUsage,
sizeInBytes: i32,
) -> *mut FNA3D_Buffer;
}
extern "C" {
pub fn FNA3D_AddDisposeVertexBuffer(device: *mut FNA3D_Device, buffer: *mut FNA3D_Buffer);
}
extern "C" {
pub fn FNA3D_SetVertexBufferData(
device: *mut FNA3D_Device,
buffer: *mut FNA3D_Buffer,
offsetInBytes: i32,
data: *mut ::std::os::raw::c_void,
elementCount: i32,
elementSizeInBytes: i32,
vertexStride: i32,
options: FNA3D_SetDataOptions,
);
}
extern "C" {
pub fn FNA3D_GetVertexBufferData(
device: *mut FNA3D_Device,
buffer: *mut FNA3D_Buffer,
offsetInBytes: i32,
data: *mut ::std::os::raw::c_void,
elementCount: i32,
elementSizeInBytes: i32,
vertexStride: i32,
);
}
extern "C" {
pub fn FNA3D_GenIndexBuffer(
device: *mut FNA3D_Device,
dynamic: u8,
usage: FNA3D_BufferUsage,
sizeInBytes: i32,
) -> *mut FNA3D_Buffer;
}
extern "C" {
pub fn FNA3D_AddDisposeIndexBuffer(device: *mut FNA3D_Device, buffer: *mut FNA3D_Buffer);
}
extern "C" {
pub fn FNA3D_SetIndexBufferData(
device: *mut FNA3D_Device,
buffer: *mut FNA3D_Buffer,
offsetInBytes: i32,
data: *mut ::std::os::raw::c_void,
dataLength: i32,
options: FNA3D_SetDataOptions,
);
}
extern "C" {
pub fn FNA3D_GetIndexBufferData(
device: *mut FNA3D_Device,
buffer: *mut FNA3D_Buffer,
offsetInBytes: i32,
data: *mut ::std::os::raw::c_void,
dataLength: i32,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_effect {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_effectTechnique {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_effectStateChanges {
_unused: [u8; 0],
}
extern "C" {
pub fn FNA3D_CreateEffect(
device: *mut FNA3D_Device,
effectCode: *mut u8,
effectCodeLength: u32,
effect: *mut *mut FNA3D_Effect,
effectData: *mut *mut MOJOSHADER_effect,
);
}
extern "C" {
pub fn FNA3D_CloneEffect(
device: *mut FNA3D_Device,
cloneSource: *mut FNA3D_Effect,
effect: *mut *mut FNA3D_Effect,
effectData: *mut *mut MOJOSHADER_effect,
);
}
extern "C" {
pub fn FNA3D_AddDisposeEffect(device: *mut FNA3D_Device, effect: *mut FNA3D_Effect);
}
extern "C" {
pub fn FNA3D_SetEffectTechnique(
device: *mut FNA3D_Device,
effect: *mut FNA3D_Effect,
technique: *mut MOJOSHADER_effectTechnique,
);
}
extern "C" {
pub fn FNA3D_ApplyEffect(
device: *mut FNA3D_Device,
effect: *mut FNA3D_Effect,
pass: u32,
stateChanges: *mut MOJOSHADER_effectStateChanges,
);
}
extern "C" {
pub fn FNA3D_BeginPassRestore(
device: *mut FNA3D_Device,
effect: *mut FNA3D_Effect,
stateChanges: *mut MOJOSHADER_effectStateChanges,
);
}
extern "C" {
pub fn FNA3D_EndPassRestore(device: *mut FNA3D_Device, effect: *mut FNA3D_Effect);
}
extern "C" {
pub fn FNA3D_CreateQuery(device: *mut FNA3D_Device) -> *mut FNA3D_Query;
}
extern "C" {
pub fn FNA3D_AddDisposeQuery(device: *mut FNA3D_Device, query: *mut FNA3D_Query);
}
extern "C" {
pub fn FNA3D_QueryBegin(device: *mut FNA3D_Device, query: *mut FNA3D_Query);
}
extern "C" {
pub fn FNA3D_QueryEnd(device: *mut FNA3D_Device, query: *mut FNA3D_Query);
}
extern "C" {
pub fn FNA3D_QueryComplete(device: *mut FNA3D_Device, query: *mut FNA3D_Query) -> u8;
}
extern "C" {
pub fn FNA3D_QueryPixelCount(device: *mut FNA3D_Device, query: *mut FNA3D_Query) -> i32;
}
extern "C" {
pub fn FNA3D_SupportsDXT1(device: *mut FNA3D_Device) -> u8;
}
extern "C" {
pub fn FNA3D_SupportsS3TC(device: *mut FNA3D_Device) -> u8;
}
extern "C" {
pub fn FNA3D_SupportsHardwareInstancing(device: *mut FNA3D_Device) -> u8;
}
extern "C" {
pub fn FNA3D_SupportsNoOverwrite(device: *mut FNA3D_Device) -> u8;
}
extern "C" {
pub fn FNA3D_GetMaxTextureSlots(
device: *mut FNA3D_Device,
textures: *mut i32,
vertexTextures: *mut i32,
);
}
extern "C" {
pub fn FNA3D_GetMaxMultiSampleCount(
device: *mut FNA3D_Device,
format: FNA3D_SurfaceFormat,
multiSampleCount: i32,
) -> i32;
}
extern "C" {
pub fn FNA3D_SetStringMarker(device: *mut FNA3D_Device, text: *const ::std::os::raw::c_char);
}
pub type FNA3D_Image_ReadFunc = ::std::option::Option<
unsafe extern "C" fn(
context: *mut ::std::os::raw::c_void,
data: *mut ::std::os::raw::c_char,
size: i32,
) -> i32,
>;
pub type FNA3D_Image_SkipFunc =
::std::option::Option<unsafe extern "C" fn(context: *mut ::std::os::raw::c_void, n: i32)>;
pub type FNA3D_Image_EOFFunc =
::std::option::Option<unsafe extern "C" fn(context: *mut ::std::os::raw::c_void) -> i32>;
extern "C" {
pub fn FNA3D_Image_Load(
readFunc: FNA3D_Image_ReadFunc,
skipFunc: FNA3D_Image_SkipFunc,
eofFunc: FNA3D_Image_EOFFunc,
context: *mut ::std::os::raw::c_void,
w: *mut i32,
h: *mut i32,
len: *mut i32,
forceW: i32,
forceH: i32,
zoom: u8,
) -> *mut u8;
}
extern "C" {
pub fn FNA3D_Image_Free(mem: *mut u8);
}
pub type FNA3D_Image_WriteFunc = ::std::option::Option<
unsafe extern "C" fn(
context: *mut ::std::os::raw::c_void,
data: *mut ::std::os::raw::c_void,
size: i32,
),
>;
extern "C" {
pub fn FNA3D_Image_SavePNG(
writeFunc: FNA3D_Image_WriteFunc,
context: *mut ::std::os::raw::c_void,
srcW: i32,
srcH: i32,
dstW: i32,
dstH: i32,
data: *mut u8,
);
}
extern "C" {
pub fn FNA3D_Image_SaveJPG(
writeFunc: FNA3D_Image_WriteFunc,
context: *mut ::std::os::raw::c_void,
srcW: i32,
srcH: i32,
dstW: i32,
dstH: i32,
data: *mut u8,
quality: i32,
);
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
pub gp_offset: ::std::os::raw::c_uint,
pub fp_offset: ::std::os::raw::c_uint,
pub overflow_arg_area: *mut ::std::os::raw::c_void,
pub reg_save_area: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
assert_eq!(
::std::mem::size_of::<__va_list_tag>(),
24usize,
concat!("Size of: ", stringify!(__va_list_tag))
);
assert_eq!(
::std::mem::align_of::<__va_list_tag>(),
8usize,
concat!("Alignment of ", stringify!(__va_list_tag))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(gp_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(fp_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(overflow_arg_area)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(reg_save_area)
)
);
}