pub const RAYGUI_VERSION_MAJOR: u32 = 4;
pub const RAYGUI_VERSION_MINOR: u32 = 0;
pub const RAYGUI_VERSION_PATCH: u32 = 0;
pub const RAYGUI_VERSION: &[u8; 4] = b"4.0\0";
pub const __GNUC_VA_LIST: u32 = 1;
pub const RAYLIB_VERSION_MAJOR: u32 = 5;
pub const RAYLIB_VERSION_MINOR: u32 = 0;
pub const RAYLIB_VERSION_PATCH: u32 = 0;
pub const RAYLIB_VERSION: &[u8; 4] = b"5.0\0";
pub const PI: f64 = 3.141592653589793;
pub const DEG2RAD: f64 = 0.017453292519943295;
pub const RAD2DEG: f64 = 57.29577951308232;
pub const true_: u32 = 1;
pub const false_: u32 = 0;
pub const __bool_true_false_are_defined: u32 = 1;
pub const SCROLLBAR_LEFT_SIDE: u32 = 0;
pub const SCROLLBAR_RIGHT_SIDE: u32 = 1;
pub const RLGL_VERSION: &[u8; 4] = b"4.5\0";
pub const RL_DEFAULT_BATCH_BUFFER_ELEMENTS: u32 = 8192;
pub const RL_DEFAULT_BATCH_BUFFERS: u32 = 1;
pub const RL_DEFAULT_BATCH_DRAWCALLS: u32 = 256;
pub const RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS: u32 = 4;
pub const RL_MAX_MATRIX_STACK_SIZE: u32 = 32;
pub const RL_MAX_SHADER_LOCATIONS: u32 = 32;
pub const RL_CULL_DISTANCE_NEAR: f64 = 0.01;
pub const RL_CULL_DISTANCE_FAR: f64 = 1000.0;
pub const RL_TEXTURE_WRAP_S: u32 = 10242;
pub const RL_TEXTURE_WRAP_T: u32 = 10243;
pub const RL_TEXTURE_MAG_FILTER: u32 = 10240;
pub const RL_TEXTURE_MIN_FILTER: u32 = 10241;
pub const RL_TEXTURE_FILTER_NEAREST: u32 = 9728;
pub const RL_TEXTURE_FILTER_LINEAR: u32 = 9729;
pub const RL_TEXTURE_FILTER_MIP_NEAREST: u32 = 9984;
pub const RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR: u32 = 9986;
pub const RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST: u32 = 9985;
pub const RL_TEXTURE_FILTER_MIP_LINEAR: u32 = 9987;
pub const RL_TEXTURE_FILTER_ANISOTROPIC: u32 = 12288;
pub const RL_TEXTURE_MIPMAP_BIAS_RATIO: u32 = 16384;
pub const RL_TEXTURE_WRAP_REPEAT: u32 = 10497;
pub const RL_TEXTURE_WRAP_CLAMP: u32 = 33071;
pub const RL_TEXTURE_WRAP_MIRROR_REPEAT: u32 = 33648;
pub const RL_TEXTURE_WRAP_MIRROR_CLAMP: u32 = 34626;
pub const RL_MODELVIEW: u32 = 5888;
pub const RL_PROJECTION: u32 = 5889;
pub const RL_TEXTURE: u32 = 5890;
pub const RL_LINES: u32 = 1;
pub const RL_TRIANGLES: u32 = 4;
pub const RL_QUADS: u32 = 7;
pub const RL_UNSIGNED_BYTE: u32 = 5121;
pub const RL_FLOAT: u32 = 5126;
pub const RL_STREAM_DRAW: u32 = 35040;
pub const RL_STREAM_READ: u32 = 35041;
pub const RL_STREAM_COPY: u32 = 35042;
pub const RL_STATIC_DRAW: u32 = 35044;
pub const RL_STATIC_READ: u32 = 35045;
pub const RL_STATIC_COPY: u32 = 35046;
pub const RL_DYNAMIC_DRAW: u32 = 35048;
pub const RL_DYNAMIC_READ: u32 = 35049;
pub const RL_DYNAMIC_COPY: u32 = 35050;
pub const RL_FRAGMENT_SHADER: u32 = 35632;
pub const RL_VERTEX_SHADER: u32 = 35633;
pub const RL_COMPUTE_SHADER: u32 = 37305;
pub const RL_ZERO: u32 = 0;
pub const RL_ONE: u32 = 1;
pub const RL_SRC_COLOR: u32 = 768;
pub const RL_ONE_MINUS_SRC_COLOR: u32 = 769;
pub const RL_SRC_ALPHA: u32 = 770;
pub const RL_ONE_MINUS_SRC_ALPHA: u32 = 771;
pub const RL_DST_ALPHA: u32 = 772;
pub const RL_ONE_MINUS_DST_ALPHA: u32 = 773;
pub const RL_DST_COLOR: u32 = 774;
pub const RL_ONE_MINUS_DST_COLOR: u32 = 775;
pub const RL_SRC_ALPHA_SATURATE: u32 = 776;
pub const RL_CONSTANT_COLOR: u32 = 32769;
pub const RL_ONE_MINUS_CONSTANT_COLOR: u32 = 32770;
pub const RL_CONSTANT_ALPHA: u32 = 32771;
pub const RL_ONE_MINUS_CONSTANT_ALPHA: u32 = 32772;
pub const RL_FUNC_ADD: u32 = 32774;
pub const RL_MIN: u32 = 32775;
pub const RL_MAX: u32 = 32776;
pub const RL_FUNC_SUBTRACT: u32 = 32778;
pub const RL_FUNC_REVERSE_SUBTRACT: u32 = 32779;
pub const RL_BLEND_EQUATION: u32 = 32777;
pub const RL_BLEND_EQUATION_RGB: u32 = 32777;
pub const RL_BLEND_EQUATION_ALPHA: u32 = 34877;
pub const RL_BLEND_DST_RGB: u32 = 32968;
pub const RL_BLEND_SRC_RGB: u32 = 32969;
pub const RL_BLEND_DST_ALPHA: u32 = 32970;
pub const RL_BLEND_SRC_ALPHA: u32 = 32971;
pub const RL_BLEND_COLOR: u32 = 32773;
pub type va_list = __builtin_va_list;
pub type __gnuc_va_list = __builtin_va_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Vector2 {
pub x: f32,
pub y: f32,
}
#[test]
fn bindgen_test_layout_Vector2() {
const UNINIT: ::std::mem::MaybeUninit<Vector2> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Vector2>(),
8usize,
concat!("Size of: ", stringify!(Vector2))
);
assert_eq!(
::std::mem::align_of::<Vector2>(),
4usize,
concat!("Alignment of ", stringify!(Vector2))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Vector2),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(Vector2),
"::",
stringify!(y)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Vector3 {
pub x: f32,
pub y: f32,
pub z: f32,
}
#[test]
fn bindgen_test_layout_Vector3() {
const UNINIT: ::std::mem::MaybeUninit<Vector3> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Vector3>(),
12usize,
concat!("Size of: ", stringify!(Vector3))
);
assert_eq!(
::std::mem::align_of::<Vector3>(),
4usize,
concat!("Alignment of ", stringify!(Vector3))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Vector3),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(Vector3),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(Vector3),
"::",
stringify!(z)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Vector4 {
pub x: f32,
pub y: f32,
pub z: f32,
pub w: f32,
}
#[test]
fn bindgen_test_layout_Vector4() {
const UNINIT: ::std::mem::MaybeUninit<Vector4> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Vector4>(),
16usize,
concat!("Size of: ", stringify!(Vector4))
);
assert_eq!(
::std::mem::align_of::<Vector4>(),
4usize,
concat!("Alignment of ", stringify!(Vector4))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Vector4),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(Vector4),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(Vector4),
"::",
stringify!(z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(Vector4),
"::",
stringify!(w)
)
);
}
pub type Quaternion = Vector4;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Matrix {
pub m0: f32,
pub m4: f32,
pub m8: f32,
pub m12: f32,
pub m1: f32,
pub m5: f32,
pub m9: f32,
pub m13: f32,
pub m2: f32,
pub m6: f32,
pub m10: f32,
pub m14: f32,
pub m3: f32,
pub m7: f32,
pub m11: f32,
pub m15: f32,
}
#[test]
fn bindgen_test_layout_Matrix() {
const UNINIT: ::std::mem::MaybeUninit<Matrix> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Matrix>(),
64usize,
concat!("Size of: ", stringify!(Matrix))
);
assert_eq!(
::std::mem::align_of::<Matrix>(),
4usize,
concat!("Alignment of ", stringify!(Matrix))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).m0) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Matrix),
"::",
stringify!(m0)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).m4) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(Matrix),
"::",
stringify!(m4)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).m8) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(Matrix),
"::",
stringify!(m8)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).m12) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(Matrix),
"::",
stringify!(m12)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).m1) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(Matrix),
"::",
stringify!(m1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).m5) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(Matrix),
"::",
stringify!(m5)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).m9) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(Matrix),
"::",
stringify!(m9)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).m13) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(Matrix),
"::",
stringify!(m13)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).m2) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(Matrix),
"::",
stringify!(m2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).m6) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(Matrix),
"::",
stringify!(m6)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).m10) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(Matrix),
"::",
stringify!(m10)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).m14) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(Matrix),
"::",
stringify!(m14)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).m3) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(Matrix),
"::",
stringify!(m3)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).m7) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(Matrix),
"::",
stringify!(m7)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).m11) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(Matrix),
"::",
stringify!(m11)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).m15) as usize - ptr as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(Matrix),
"::",
stringify!(m15)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Color {
pub r: ::std::os::raw::c_uchar,
pub g: ::std::os::raw::c_uchar,
pub b: ::std::os::raw::c_uchar,
pub a: ::std::os::raw::c_uchar,
}
#[test]
fn bindgen_test_layout_Color() {
const UNINIT: ::std::mem::MaybeUninit<Color> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Color>(),
4usize,
concat!("Size of: ", stringify!(Color))
);
assert_eq!(
::std::mem::align_of::<Color>(),
1usize,
concat!("Alignment of ", stringify!(Color))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
0usize,
concat!("Offset of field: ", stringify!(Color), "::", stringify!(r))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
1usize,
concat!("Offset of field: ", stringify!(Color), "::", stringify!(g))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
2usize,
concat!("Offset of field: ", stringify!(Color), "::", stringify!(b))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
3usize,
concat!("Offset of field: ", stringify!(Color), "::", stringify!(a))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Rectangle {
pub x: f32,
pub y: f32,
pub width: f32,
pub height: f32,
}
#[test]
fn bindgen_test_layout_Rectangle() {
const UNINIT: ::std::mem::MaybeUninit<Rectangle> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Rectangle>(),
16usize,
concat!("Size of: ", stringify!(Rectangle))
);
assert_eq!(
::std::mem::align_of::<Rectangle>(),
4usize,
concat!("Alignment of ", stringify!(Rectangle))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Rectangle),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(Rectangle),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(Rectangle),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(Rectangle),
"::",
stringify!(height)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Image {
pub data: *mut ::std::os::raw::c_void,
pub width: ::std::os::raw::c_int,
pub height: ::std::os::raw::c_int,
pub mipmaps: ::std::os::raw::c_int,
pub format: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_Image() {
const UNINIT: ::std::mem::MaybeUninit<Image> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Image>(),
24usize,
concat!("Size of: ", stringify!(Image))
);
assert_eq!(
::std::mem::align_of::<Image>(),
8usize,
concat!("Alignment of ", stringify!(Image))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Image),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(Image),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(Image),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mipmaps) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(Image),
"::",
stringify!(mipmaps)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(Image),
"::",
stringify!(format)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Texture {
pub id: ::std::os::raw::c_uint,
pub width: ::std::os::raw::c_int,
pub height: ::std::os::raw::c_int,
pub mipmaps: ::std::os::raw::c_int,
pub format: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_Texture() {
const UNINIT: ::std::mem::MaybeUninit<Texture> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Texture>(),
20usize,
concat!("Size of: ", stringify!(Texture))
);
assert_eq!(
::std::mem::align_of::<Texture>(),
4usize,
concat!("Alignment of ", stringify!(Texture))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Texture),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(Texture),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(Texture),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mipmaps) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(Texture),
"::",
stringify!(mipmaps)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(Texture),
"::",
stringify!(format)
)
);
}
pub type Texture2D = Texture;
pub type TextureCubemap = Texture;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RenderTexture {
pub id: ::std::os::raw::c_uint,
pub texture: Texture,
pub depth: Texture,
}
#[test]
fn bindgen_test_layout_RenderTexture() {
const UNINIT: ::std::mem::MaybeUninit<RenderTexture> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<RenderTexture>(),
44usize,
concat!("Size of: ", stringify!(RenderTexture))
);
assert_eq!(
::std::mem::align_of::<RenderTexture>(),
4usize,
concat!("Alignment of ", stringify!(RenderTexture))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RenderTexture),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).texture) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RenderTexture),
"::",
stringify!(texture)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RenderTexture),
"::",
stringify!(depth)
)
);
}
pub type RenderTexture2D = RenderTexture;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct NPatchInfo {
pub source: Rectangle,
pub left: ::std::os::raw::c_int,
pub top: ::std::os::raw::c_int,
pub right: ::std::os::raw::c_int,
pub bottom: ::std::os::raw::c_int,
pub layout: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_NPatchInfo() {
const UNINIT: ::std::mem::MaybeUninit<NPatchInfo> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<NPatchInfo>(),
36usize,
concat!("Size of: ", stringify!(NPatchInfo))
);
assert_eq!(
::std::mem::align_of::<NPatchInfo>(),
4usize,
concat!("Alignment of ", stringify!(NPatchInfo))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).source) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(NPatchInfo),
"::",
stringify!(source)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).left) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(NPatchInfo),
"::",
stringify!(left)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).top) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(NPatchInfo),
"::",
stringify!(top)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).right) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(NPatchInfo),
"::",
stringify!(right)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bottom) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(NPatchInfo),
"::",
stringify!(bottom)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).layout) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(NPatchInfo),
"::",
stringify!(layout)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GlyphInfo {
pub value: ::std::os::raw::c_int,
pub offsetX: ::std::os::raw::c_int,
pub offsetY: ::std::os::raw::c_int,
pub advanceX: ::std::os::raw::c_int,
pub image: Image,
}
#[test]
fn bindgen_test_layout_GlyphInfo() {
const UNINIT: ::std::mem::MaybeUninit<GlyphInfo> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GlyphInfo>(),
40usize,
concat!("Size of: ", stringify!(GlyphInfo))
);
assert_eq!(
::std::mem::align_of::<GlyphInfo>(),
8usize,
concat!("Alignment of ", stringify!(GlyphInfo))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GlyphInfo),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).offsetX) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(GlyphInfo),
"::",
stringify!(offsetX)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).offsetY) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(GlyphInfo),
"::",
stringify!(offsetY)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).advanceX) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(GlyphInfo),
"::",
stringify!(advanceX)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).image) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(GlyphInfo),
"::",
stringify!(image)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Font {
pub baseSize: ::std::os::raw::c_int,
pub glyphCount: ::std::os::raw::c_int,
pub glyphPadding: ::std::os::raw::c_int,
pub texture: Texture2D,
pub recs: *mut Rectangle,
pub glyphs: *mut GlyphInfo,
}
#[test]
fn bindgen_test_layout_Font() {
const UNINIT: ::std::mem::MaybeUninit<Font> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Font>(),
48usize,
concat!("Size of: ", stringify!(Font))
);
assert_eq!(
::std::mem::align_of::<Font>(),
8usize,
concat!("Alignment of ", stringify!(Font))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).baseSize) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Font),
"::",
stringify!(baseSize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).glyphCount) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(Font),
"::",
stringify!(glyphCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).glyphPadding) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(Font),
"::",
stringify!(glyphPadding)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).texture) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(Font),
"::",
stringify!(texture)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).recs) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(Font),
"::",
stringify!(recs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).glyphs) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(Font),
"::",
stringify!(glyphs)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Camera3D {
pub position: Vector3,
pub target: Vector3,
pub up: Vector3,
pub fovy: f32,
pub projection: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_Camera3D() {
const UNINIT: ::std::mem::MaybeUninit<Camera3D> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Camera3D>(),
44usize,
concat!("Size of: ", stringify!(Camera3D))
);
assert_eq!(
::std::mem::align_of::<Camera3D>(),
4usize,
concat!("Alignment of ", stringify!(Camera3D))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Camera3D),
"::",
stringify!(position)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(Camera3D),
"::",
stringify!(target)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).up) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(Camera3D),
"::",
stringify!(up)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fovy) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(Camera3D),
"::",
stringify!(fovy)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).projection) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(Camera3D),
"::",
stringify!(projection)
)
);
}
pub type Camera = Camera3D;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Camera2D {
pub offset: Vector2,
pub target: Vector2,
pub rotation: f32,
pub zoom: f32,
}
#[test]
fn bindgen_test_layout_Camera2D() {
const UNINIT: ::std::mem::MaybeUninit<Camera2D> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Camera2D>(),
24usize,
concat!("Size of: ", stringify!(Camera2D))
);
assert_eq!(
::std::mem::align_of::<Camera2D>(),
4usize,
concat!("Alignment of ", stringify!(Camera2D))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Camera2D),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(Camera2D),
"::",
stringify!(target)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rotation) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(Camera2D),
"::",
stringify!(rotation)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).zoom) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(Camera2D),
"::",
stringify!(zoom)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Mesh {
pub vertexCount: ::std::os::raw::c_int,
pub triangleCount: ::std::os::raw::c_int,
pub vertices: *mut f32,
pub texcoords: *mut f32,
pub texcoords2: *mut f32,
pub normals: *mut f32,
pub tangents: *mut f32,
pub colors: *mut ::std::os::raw::c_uchar,
pub indices: *mut ::std::os::raw::c_ushort,
pub animVertices: *mut f32,
pub animNormals: *mut f32,
pub boneIds: *mut ::std::os::raw::c_uchar,
pub boneWeights: *mut f32,
pub vaoId: ::std::os::raw::c_uint,
pub vboId: *mut ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_Mesh() {
const UNINIT: ::std::mem::MaybeUninit<Mesh> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Mesh>(),
112usize,
concat!("Size of: ", stringify!(Mesh))
);
assert_eq!(
::std::mem::align_of::<Mesh>(),
8usize,
concat!("Alignment of ", stringify!(Mesh))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vertexCount) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Mesh),
"::",
stringify!(vertexCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).triangleCount) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(Mesh),
"::",
stringify!(triangleCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vertices) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(Mesh),
"::",
stringify!(vertices)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).texcoords) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(Mesh),
"::",
stringify!(texcoords)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).texcoords2) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(Mesh),
"::",
stringify!(texcoords2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).normals) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(Mesh),
"::",
stringify!(normals)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tangents) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(Mesh),
"::",
stringify!(tangents)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).colors) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(Mesh),
"::",
stringify!(colors)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).indices) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(Mesh),
"::",
stringify!(indices)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).animVertices) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(Mesh),
"::",
stringify!(animVertices)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).animNormals) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(Mesh),
"::",
stringify!(animNormals)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).boneIds) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(Mesh),
"::",
stringify!(boneIds)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).boneWeights) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(Mesh),
"::",
stringify!(boneWeights)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vaoId) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(Mesh),
"::",
stringify!(vaoId)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vboId) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(Mesh),
"::",
stringify!(vboId)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Shader {
pub id: ::std::os::raw::c_uint,
pub locs: *mut ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_Shader() {
const UNINIT: ::std::mem::MaybeUninit<Shader> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Shader>(),
16usize,
concat!("Size of: ", stringify!(Shader))
);
assert_eq!(
::std::mem::align_of::<Shader>(),
8usize,
concat!("Alignment of ", stringify!(Shader))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Shader),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).locs) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(Shader),
"::",
stringify!(locs)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MaterialMap {
pub texture: Texture2D,
pub color: Color,
pub value: f32,
}
#[test]
fn bindgen_test_layout_MaterialMap() {
const UNINIT: ::std::mem::MaybeUninit<MaterialMap> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MaterialMap>(),
28usize,
concat!("Size of: ", stringify!(MaterialMap))
);
assert_eq!(
::std::mem::align_of::<MaterialMap>(),
4usize,
concat!("Alignment of ", stringify!(MaterialMap))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).texture) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MaterialMap),
"::",
stringify!(texture)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).color) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(MaterialMap),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(MaterialMap),
"::",
stringify!(value)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Material {
pub shader: Shader,
pub maps: *mut MaterialMap,
pub params: [f32; 4usize],
}
#[test]
fn bindgen_test_layout_Material() {
const UNINIT: ::std::mem::MaybeUninit<Material> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Material>(),
40usize,
concat!("Size of: ", stringify!(Material))
);
assert_eq!(
::std::mem::align_of::<Material>(),
8usize,
concat!("Alignment of ", stringify!(Material))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).shader) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Material),
"::",
stringify!(shader)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maps) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(Material),
"::",
stringify!(maps)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).params) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(Material),
"::",
stringify!(params)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Transform {
pub translation: Vector3,
pub rotation: Quaternion,
pub scale: Vector3,
}
#[test]
fn bindgen_test_layout_Transform() {
const UNINIT: ::std::mem::MaybeUninit<Transform> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Transform>(),
40usize,
concat!("Size of: ", stringify!(Transform))
);
assert_eq!(
::std::mem::align_of::<Transform>(),
4usize,
concat!("Alignment of ", stringify!(Transform))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).translation) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Transform),
"::",
stringify!(translation)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rotation) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(Transform),
"::",
stringify!(rotation)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).scale) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(Transform),
"::",
stringify!(scale)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct BoneInfo {
pub name: [::std::os::raw::c_char; 32usize],
pub parent: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_BoneInfo() {
const UNINIT: ::std::mem::MaybeUninit<BoneInfo> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<BoneInfo>(),
36usize,
concat!("Size of: ", stringify!(BoneInfo))
);
assert_eq!(
::std::mem::align_of::<BoneInfo>(),
4usize,
concat!("Alignment of ", stringify!(BoneInfo))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(BoneInfo),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(BoneInfo),
"::",
stringify!(parent)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Model {
pub transform: Matrix,
pub meshCount: ::std::os::raw::c_int,
pub materialCount: ::std::os::raw::c_int,
pub meshes: *mut Mesh,
pub materials: *mut Material,
pub meshMaterial: *mut ::std::os::raw::c_int,
pub boneCount: ::std::os::raw::c_int,
pub bones: *mut BoneInfo,
pub bindPose: *mut Transform,
}
#[test]
fn bindgen_test_layout_Model() {
const UNINIT: ::std::mem::MaybeUninit<Model> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Model>(),
120usize,
concat!("Size of: ", stringify!(Model))
);
assert_eq!(
::std::mem::align_of::<Model>(),
8usize,
concat!("Alignment of ", stringify!(Model))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).transform) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Model),
"::",
stringify!(transform)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).meshCount) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(Model),
"::",
stringify!(meshCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).materialCount) as usize - ptr as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(Model),
"::",
stringify!(materialCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).meshes) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(Model),
"::",
stringify!(meshes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).materials) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(Model),
"::",
stringify!(materials)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).meshMaterial) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(Model),
"::",
stringify!(meshMaterial)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).boneCount) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(Model),
"::",
stringify!(boneCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bones) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(Model),
"::",
stringify!(bones)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bindPose) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(Model),
"::",
stringify!(bindPose)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ModelAnimation {
pub boneCount: ::std::os::raw::c_int,
pub frameCount: ::std::os::raw::c_int,
pub bones: *mut BoneInfo,
pub framePoses: *mut *mut Transform,
pub name: [::std::os::raw::c_char; 32usize],
}
#[test]
fn bindgen_test_layout_ModelAnimation() {
const UNINIT: ::std::mem::MaybeUninit<ModelAnimation> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ModelAnimation>(),
56usize,
concat!("Size of: ", stringify!(ModelAnimation))
);
assert_eq!(
::std::mem::align_of::<ModelAnimation>(),
8usize,
concat!("Alignment of ", stringify!(ModelAnimation))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).boneCount) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ModelAnimation),
"::",
stringify!(boneCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).frameCount) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ModelAnimation),
"::",
stringify!(frameCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bones) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ModelAnimation),
"::",
stringify!(bones)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).framePoses) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ModelAnimation),
"::",
stringify!(framePoses)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ModelAnimation),
"::",
stringify!(name)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Ray {
pub position: Vector3,
pub direction: Vector3,
}
#[test]
fn bindgen_test_layout_Ray() {
const UNINIT: ::std::mem::MaybeUninit<Ray> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Ray>(),
24usize,
concat!("Size of: ", stringify!(Ray))
);
assert_eq!(
::std::mem::align_of::<Ray>(),
4usize,
concat!("Alignment of ", stringify!(Ray))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Ray),
"::",
stringify!(position)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(Ray),
"::",
stringify!(direction)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RayCollision {
pub hit: bool,
pub distance: f32,
pub point: Vector3,
pub normal: Vector3,
}
#[test]
fn bindgen_test_layout_RayCollision() {
const UNINIT: ::std::mem::MaybeUninit<RayCollision> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<RayCollision>(),
32usize,
concat!("Size of: ", stringify!(RayCollision))
);
assert_eq!(
::std::mem::align_of::<RayCollision>(),
4usize,
concat!("Alignment of ", stringify!(RayCollision))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hit) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RayCollision),
"::",
stringify!(hit)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).distance) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RayCollision),
"::",
stringify!(distance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).point) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RayCollision),
"::",
stringify!(point)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).normal) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RayCollision),
"::",
stringify!(normal)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct BoundingBox {
pub min: Vector3,
pub max: Vector3,
}
#[test]
fn bindgen_test_layout_BoundingBox() {
const UNINIT: ::std::mem::MaybeUninit<BoundingBox> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<BoundingBox>(),
24usize,
concat!("Size of: ", stringify!(BoundingBox))
);
assert_eq!(
::std::mem::align_of::<BoundingBox>(),
4usize,
concat!("Alignment of ", stringify!(BoundingBox))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(BoundingBox),
"::",
stringify!(min)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(BoundingBox),
"::",
stringify!(max)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Wave {
pub frameCount: ::std::os::raw::c_uint,
pub sampleRate: ::std::os::raw::c_uint,
pub sampleSize: ::std::os::raw::c_uint,
pub channels: ::std::os::raw::c_uint,
pub data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_Wave() {
const UNINIT: ::std::mem::MaybeUninit<Wave> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Wave>(),
24usize,
concat!("Size of: ", stringify!(Wave))
);
assert_eq!(
::std::mem::align_of::<Wave>(),
8usize,
concat!("Alignment of ", stringify!(Wave))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).frameCount) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Wave),
"::",
stringify!(frameCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sampleRate) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(Wave),
"::",
stringify!(sampleRate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sampleSize) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(Wave),
"::",
stringify!(sampleSize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(Wave),
"::",
stringify!(channels)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(Wave),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rAudioBuffer {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rAudioProcessor {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AudioStream {
pub buffer: *mut rAudioBuffer,
pub processor: *mut rAudioProcessor,
pub sampleRate: ::std::os::raw::c_uint,
pub sampleSize: ::std::os::raw::c_uint,
pub channels: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_AudioStream() {
const UNINIT: ::std::mem::MaybeUninit<AudioStream> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<AudioStream>(),
32usize,
concat!("Size of: ", stringify!(AudioStream))
);
assert_eq!(
::std::mem::align_of::<AudioStream>(),
8usize,
concat!("Alignment of ", stringify!(AudioStream))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(AudioStream),
"::",
stringify!(buffer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).processor) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(AudioStream),
"::",
stringify!(processor)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sampleRate) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(AudioStream),
"::",
stringify!(sampleRate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sampleSize) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(AudioStream),
"::",
stringify!(sampleSize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(AudioStream),
"::",
stringify!(channels)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Sound {
pub stream: AudioStream,
pub frameCount: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_Sound() {
const UNINIT: ::std::mem::MaybeUninit<Sound> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Sound>(),
40usize,
concat!("Size of: ", stringify!(Sound))
);
assert_eq!(
::std::mem::align_of::<Sound>(),
8usize,
concat!("Alignment of ", stringify!(Sound))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stream) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Sound),
"::",
stringify!(stream)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).frameCount) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(Sound),
"::",
stringify!(frameCount)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Music {
pub stream: AudioStream,
pub frameCount: ::std::os::raw::c_uint,
pub looping: bool,
pub ctxType: ::std::os::raw::c_int,
pub ctxData: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_Music() {
const UNINIT: ::std::mem::MaybeUninit<Music> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Music>(),
56usize,
concat!("Size of: ", stringify!(Music))
);
assert_eq!(
::std::mem::align_of::<Music>(),
8usize,
concat!("Alignment of ", stringify!(Music))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stream) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Music),
"::",
stringify!(stream)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).frameCount) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(Music),
"::",
stringify!(frameCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).looping) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(Music),
"::",
stringify!(looping)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ctxType) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(Music),
"::",
stringify!(ctxType)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ctxData) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(Music),
"::",
stringify!(ctxData)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VrDeviceInfo {
pub hResolution: ::std::os::raw::c_int,
pub vResolution: ::std::os::raw::c_int,
pub hScreenSize: f32,
pub vScreenSize: f32,
pub vScreenCenter: f32,
pub eyeToScreenDistance: f32,
pub lensSeparationDistance: f32,
pub interpupillaryDistance: f32,
pub lensDistortionValues: [f32; 4usize],
pub chromaAbCorrection: [f32; 4usize],
}
#[test]
fn bindgen_test_layout_VrDeviceInfo() {
const UNINIT: ::std::mem::MaybeUninit<VrDeviceInfo> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<VrDeviceInfo>(),
64usize,
concat!("Size of: ", stringify!(VrDeviceInfo))
);
assert_eq!(
::std::mem::align_of::<VrDeviceInfo>(),
4usize,
concat!("Alignment of ", stringify!(VrDeviceInfo))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hResolution) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(VrDeviceInfo),
"::",
stringify!(hResolution)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vResolution) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(VrDeviceInfo),
"::",
stringify!(vResolution)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hScreenSize) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(VrDeviceInfo),
"::",
stringify!(hScreenSize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vScreenSize) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(VrDeviceInfo),
"::",
stringify!(vScreenSize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vScreenCenter) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(VrDeviceInfo),
"::",
stringify!(vScreenCenter)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).eyeToScreenDistance) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(VrDeviceInfo),
"::",
stringify!(eyeToScreenDistance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lensSeparationDistance) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(VrDeviceInfo),
"::",
stringify!(lensSeparationDistance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).interpupillaryDistance) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(VrDeviceInfo),
"::",
stringify!(interpupillaryDistance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lensDistortionValues) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(VrDeviceInfo),
"::",
stringify!(lensDistortionValues)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).chromaAbCorrection) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(VrDeviceInfo),
"::",
stringify!(chromaAbCorrection)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VrStereoConfig {
pub projection: [Matrix; 2usize],
pub viewOffset: [Matrix; 2usize],
pub leftLensCenter: [f32; 2usize],
pub rightLensCenter: [f32; 2usize],
pub leftScreenCenter: [f32; 2usize],
pub rightScreenCenter: [f32; 2usize],
pub scale: [f32; 2usize],
pub scaleIn: [f32; 2usize],
}
#[test]
fn bindgen_test_layout_VrStereoConfig() {
const UNINIT: ::std::mem::MaybeUninit<VrStereoConfig> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<VrStereoConfig>(),
304usize,
concat!("Size of: ", stringify!(VrStereoConfig))
);
assert_eq!(
::std::mem::align_of::<VrStereoConfig>(),
4usize,
concat!("Alignment of ", stringify!(VrStereoConfig))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).projection) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(VrStereoConfig),
"::",
stringify!(projection)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).viewOffset) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(VrStereoConfig),
"::",
stringify!(viewOffset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).leftLensCenter) as usize - ptr as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(VrStereoConfig),
"::",
stringify!(leftLensCenter)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rightLensCenter) as usize - ptr as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(VrStereoConfig),
"::",
stringify!(rightLensCenter)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).leftScreenCenter) as usize - ptr as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(VrStereoConfig),
"::",
stringify!(leftScreenCenter)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rightScreenCenter) as usize - ptr as usize },
280usize,
concat!(
"Offset of field: ",
stringify!(VrStereoConfig),
"::",
stringify!(rightScreenCenter)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).scale) as usize - ptr as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(VrStereoConfig),
"::",
stringify!(scale)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).scaleIn) as usize - ptr as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(VrStereoConfig),
"::",
stringify!(scaleIn)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FilePathList {
pub capacity: ::std::os::raw::c_uint,
pub count: ::std::os::raw::c_uint,
pub paths: *mut *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_FilePathList() {
const UNINIT: ::std::mem::MaybeUninit<FilePathList> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<FilePathList>(),
16usize,
concat!("Size of: ", stringify!(FilePathList))
);
assert_eq!(
::std::mem::align_of::<FilePathList>(),
8usize,
concat!("Alignment of ", stringify!(FilePathList))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FilePathList),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(FilePathList),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).paths) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FilePathList),
"::",
stringify!(paths)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AutomationEvent {
pub frame: ::std::os::raw::c_uint,
pub type_: ::std::os::raw::c_uint,
pub params: [::std::os::raw::c_int; 4usize],
}
#[test]
fn bindgen_test_layout_AutomationEvent() {
const UNINIT: ::std::mem::MaybeUninit<AutomationEvent> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<AutomationEvent>(),
24usize,
concat!("Size of: ", stringify!(AutomationEvent))
);
assert_eq!(
::std::mem::align_of::<AutomationEvent>(),
4usize,
concat!("Alignment of ", stringify!(AutomationEvent))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).frame) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(AutomationEvent),
"::",
stringify!(frame)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(AutomationEvent),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).params) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(AutomationEvent),
"::",
stringify!(params)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AutomationEventList {
pub capacity: ::std::os::raw::c_uint,
pub count: ::std::os::raw::c_uint,
pub events: *mut AutomationEvent,
}
#[test]
fn bindgen_test_layout_AutomationEventList() {
const UNINIT: ::std::mem::MaybeUninit<AutomationEventList> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<AutomationEventList>(),
16usize,
concat!("Size of: ", stringify!(AutomationEventList))
);
assert_eq!(
::std::mem::align_of::<AutomationEventList>(),
8usize,
concat!("Alignment of ", stringify!(AutomationEventList))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(AutomationEventList),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(AutomationEventList),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).events) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(AutomationEventList),
"::",
stringify!(events)
)
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ConfigFlags {
FLAG_VSYNC_HINT = 64,
FLAG_FULLSCREEN_MODE = 2,
FLAG_WINDOW_RESIZABLE = 4,
FLAG_WINDOW_UNDECORATED = 8,
FLAG_WINDOW_HIDDEN = 128,
FLAG_WINDOW_MINIMIZED = 512,
FLAG_WINDOW_MAXIMIZED = 1024,
FLAG_WINDOW_UNFOCUSED = 2048,
FLAG_WINDOW_TOPMOST = 4096,
FLAG_WINDOW_ALWAYS_RUN = 256,
FLAG_WINDOW_TRANSPARENT = 16,
FLAG_WINDOW_HIGHDPI = 8192,
FLAG_WINDOW_MOUSE_PASSTHROUGH = 16384,
FLAG_BORDERLESS_WINDOWED_MODE = 32768,
FLAG_MSAA_4X_HINT = 32,
FLAG_INTERLACED_HINT = 65536,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum TraceLogLevel {
LOG_ALL = 0,
LOG_TRACE = 1,
LOG_DEBUG = 2,
LOG_INFO = 3,
LOG_WARNING = 4,
LOG_ERROR = 5,
LOG_FATAL = 6,
LOG_NONE = 7,
}
impl KeyboardKey {
pub const KEY_MENU: KeyboardKey = KeyboardKey::KEY_R;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum KeyboardKey {
KEY_NULL = 0,
KEY_APOSTROPHE = 39,
KEY_COMMA = 44,
KEY_MINUS = 45,
KEY_PERIOD = 46,
KEY_SLASH = 47,
KEY_ZERO = 48,
KEY_ONE = 49,
KEY_TWO = 50,
KEY_THREE = 51,
KEY_FOUR = 52,
KEY_FIVE = 53,
KEY_SIX = 54,
KEY_SEVEN = 55,
KEY_EIGHT = 56,
KEY_NINE = 57,
KEY_SEMICOLON = 59,
KEY_EQUAL = 61,
KEY_A = 65,
KEY_B = 66,
KEY_C = 67,
KEY_D = 68,
KEY_E = 69,
KEY_F = 70,
KEY_G = 71,
KEY_H = 72,
KEY_I = 73,
KEY_J = 74,
KEY_K = 75,
KEY_L = 76,
KEY_M = 77,
KEY_N = 78,
KEY_O = 79,
KEY_P = 80,
KEY_Q = 81,
KEY_R = 82,
KEY_S = 83,
KEY_T = 84,
KEY_U = 85,
KEY_V = 86,
KEY_W = 87,
KEY_X = 88,
KEY_Y = 89,
KEY_Z = 90,
KEY_LEFT_BRACKET = 91,
KEY_BACKSLASH = 92,
KEY_RIGHT_BRACKET = 93,
KEY_GRAVE = 96,
KEY_SPACE = 32,
KEY_ESCAPE = 256,
KEY_ENTER = 257,
KEY_TAB = 258,
KEY_BACKSPACE = 259,
KEY_INSERT = 260,
KEY_DELETE = 261,
KEY_RIGHT = 262,
KEY_LEFT = 263,
KEY_DOWN = 264,
KEY_UP = 265,
KEY_PAGE_UP = 266,
KEY_PAGE_DOWN = 267,
KEY_HOME = 268,
KEY_END = 269,
KEY_CAPS_LOCK = 280,
KEY_SCROLL_LOCK = 281,
KEY_NUM_LOCK = 282,
KEY_PRINT_SCREEN = 283,
KEY_PAUSE = 284,
KEY_F1 = 290,
KEY_F2 = 291,
KEY_F3 = 292,
KEY_F4 = 293,
KEY_F5 = 294,
KEY_F6 = 295,
KEY_F7 = 296,
KEY_F8 = 297,
KEY_F9 = 298,
KEY_F10 = 299,
KEY_F11 = 300,
KEY_F12 = 301,
KEY_LEFT_SHIFT = 340,
KEY_LEFT_CONTROL = 341,
KEY_LEFT_ALT = 342,
KEY_LEFT_SUPER = 343,
KEY_RIGHT_SHIFT = 344,
KEY_RIGHT_CONTROL = 345,
KEY_RIGHT_ALT = 346,
KEY_RIGHT_SUPER = 347,
KEY_KB_MENU = 348,
KEY_KP_0 = 320,
KEY_KP_1 = 321,
KEY_KP_2 = 322,
KEY_KP_3 = 323,
KEY_KP_4 = 324,
KEY_KP_5 = 325,
KEY_KP_6 = 326,
KEY_KP_7 = 327,
KEY_KP_8 = 328,
KEY_KP_9 = 329,
KEY_KP_DECIMAL = 330,
KEY_KP_DIVIDE = 331,
KEY_KP_MULTIPLY = 332,
KEY_KP_SUBTRACT = 333,
KEY_KP_ADD = 334,
KEY_KP_ENTER = 335,
KEY_KP_EQUAL = 336,
KEY_BACK = 4,
KEY_VOLUME_UP = 24,
KEY_VOLUME_DOWN = 25,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum MouseButton {
MOUSE_BUTTON_LEFT = 0,
MOUSE_BUTTON_RIGHT = 1,
MOUSE_BUTTON_MIDDLE = 2,
MOUSE_BUTTON_SIDE = 3,
MOUSE_BUTTON_EXTRA = 4,
MOUSE_BUTTON_FORWARD = 5,
MOUSE_BUTTON_BACK = 6,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum MouseCursor {
MOUSE_CURSOR_DEFAULT = 0,
MOUSE_CURSOR_ARROW = 1,
MOUSE_CURSOR_IBEAM = 2,
MOUSE_CURSOR_CROSSHAIR = 3,
MOUSE_CURSOR_POINTING_HAND = 4,
MOUSE_CURSOR_RESIZE_EW = 5,
MOUSE_CURSOR_RESIZE_NS = 6,
MOUSE_CURSOR_RESIZE_NWSE = 7,
MOUSE_CURSOR_RESIZE_NESW = 8,
MOUSE_CURSOR_RESIZE_ALL = 9,
MOUSE_CURSOR_NOT_ALLOWED = 10,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GamepadButton {
GAMEPAD_BUTTON_UNKNOWN = 0,
GAMEPAD_BUTTON_LEFT_FACE_UP = 1,
GAMEPAD_BUTTON_LEFT_FACE_RIGHT = 2,
GAMEPAD_BUTTON_LEFT_FACE_DOWN = 3,
GAMEPAD_BUTTON_LEFT_FACE_LEFT = 4,
GAMEPAD_BUTTON_RIGHT_FACE_UP = 5,
GAMEPAD_BUTTON_RIGHT_FACE_RIGHT = 6,
GAMEPAD_BUTTON_RIGHT_FACE_DOWN = 7,
GAMEPAD_BUTTON_RIGHT_FACE_LEFT = 8,
GAMEPAD_BUTTON_LEFT_TRIGGER_1 = 9,
GAMEPAD_BUTTON_LEFT_TRIGGER_2 = 10,
GAMEPAD_BUTTON_RIGHT_TRIGGER_1 = 11,
GAMEPAD_BUTTON_RIGHT_TRIGGER_2 = 12,
GAMEPAD_BUTTON_MIDDLE_LEFT = 13,
GAMEPAD_BUTTON_MIDDLE = 14,
GAMEPAD_BUTTON_MIDDLE_RIGHT = 15,
GAMEPAD_BUTTON_LEFT_THUMB = 16,
GAMEPAD_BUTTON_RIGHT_THUMB = 17,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GamepadAxis {
GAMEPAD_AXIS_LEFT_X = 0,
GAMEPAD_AXIS_LEFT_Y = 1,
GAMEPAD_AXIS_RIGHT_X = 2,
GAMEPAD_AXIS_RIGHT_Y = 3,
GAMEPAD_AXIS_LEFT_TRIGGER = 4,
GAMEPAD_AXIS_RIGHT_TRIGGER = 5,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum MaterialMapIndex {
MATERIAL_MAP_ALBEDO = 0,
MATERIAL_MAP_METALNESS = 1,
MATERIAL_MAP_NORMAL = 2,
MATERIAL_MAP_ROUGHNESS = 3,
MATERIAL_MAP_OCCLUSION = 4,
MATERIAL_MAP_EMISSION = 5,
MATERIAL_MAP_HEIGHT = 6,
MATERIAL_MAP_CUBEMAP = 7,
MATERIAL_MAP_IRRADIANCE = 8,
MATERIAL_MAP_PREFILTER = 9,
MATERIAL_MAP_BRDF = 10,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ShaderLocationIndex {
SHADER_LOC_VERTEX_POSITION = 0,
SHADER_LOC_VERTEX_TEXCOORD01 = 1,
SHADER_LOC_VERTEX_TEXCOORD02 = 2,
SHADER_LOC_VERTEX_NORMAL = 3,
SHADER_LOC_VERTEX_TANGENT = 4,
SHADER_LOC_VERTEX_COLOR = 5,
SHADER_LOC_MATRIX_MVP = 6,
SHADER_LOC_MATRIX_VIEW = 7,
SHADER_LOC_MATRIX_PROJECTION = 8,
SHADER_LOC_MATRIX_MODEL = 9,
SHADER_LOC_MATRIX_NORMAL = 10,
SHADER_LOC_VECTOR_VIEW = 11,
SHADER_LOC_COLOR_DIFFUSE = 12,
SHADER_LOC_COLOR_SPECULAR = 13,
SHADER_LOC_COLOR_AMBIENT = 14,
SHADER_LOC_MAP_ALBEDO = 15,
SHADER_LOC_MAP_METALNESS = 16,
SHADER_LOC_MAP_NORMAL = 17,
SHADER_LOC_MAP_ROUGHNESS = 18,
SHADER_LOC_MAP_OCCLUSION = 19,
SHADER_LOC_MAP_EMISSION = 20,
SHADER_LOC_MAP_HEIGHT = 21,
SHADER_LOC_MAP_CUBEMAP = 22,
SHADER_LOC_MAP_IRRADIANCE = 23,
SHADER_LOC_MAP_PREFILTER = 24,
SHADER_LOC_MAP_BRDF = 25,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ShaderUniformDataType {
SHADER_UNIFORM_FLOAT = 0,
SHADER_UNIFORM_VEC2 = 1,
SHADER_UNIFORM_VEC3 = 2,
SHADER_UNIFORM_VEC4 = 3,
SHADER_UNIFORM_INT = 4,
SHADER_UNIFORM_IVEC2 = 5,
SHADER_UNIFORM_IVEC3 = 6,
SHADER_UNIFORM_IVEC4 = 7,
SHADER_UNIFORM_SAMPLER2D = 8,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ShaderAttributeDataType {
SHADER_ATTRIB_FLOAT = 0,
SHADER_ATTRIB_VEC2 = 1,
SHADER_ATTRIB_VEC3 = 2,
SHADER_ATTRIB_VEC4 = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum PixelFormat {
PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1,
PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA = 2,
PIXELFORMAT_UNCOMPRESSED_R5G6B5 = 3,
PIXELFORMAT_UNCOMPRESSED_R8G8B8 = 4,
PIXELFORMAT_UNCOMPRESSED_R5G5B5A1 = 5,
PIXELFORMAT_UNCOMPRESSED_R4G4B4A4 = 6,
PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 = 7,
PIXELFORMAT_UNCOMPRESSED_R32 = 8,
PIXELFORMAT_UNCOMPRESSED_R32G32B32 = 9,
PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 = 10,
PIXELFORMAT_UNCOMPRESSED_R16 = 11,
PIXELFORMAT_UNCOMPRESSED_R16G16B16 = 12,
PIXELFORMAT_UNCOMPRESSED_R16G16B16A16 = 13,
PIXELFORMAT_COMPRESSED_DXT1_RGB = 14,
PIXELFORMAT_COMPRESSED_DXT1_RGBA = 15,
PIXELFORMAT_COMPRESSED_DXT3_RGBA = 16,
PIXELFORMAT_COMPRESSED_DXT5_RGBA = 17,
PIXELFORMAT_COMPRESSED_ETC1_RGB = 18,
PIXELFORMAT_COMPRESSED_ETC2_RGB = 19,
PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA = 20,
PIXELFORMAT_COMPRESSED_PVRT_RGB = 21,
PIXELFORMAT_COMPRESSED_PVRT_RGBA = 22,
PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA = 23,
PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA = 24,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum TextureFilter {
TEXTURE_FILTER_POINT = 0,
TEXTURE_FILTER_BILINEAR = 1,
TEXTURE_FILTER_TRILINEAR = 2,
TEXTURE_FILTER_ANISOTROPIC_4X = 3,
TEXTURE_FILTER_ANISOTROPIC_8X = 4,
TEXTURE_FILTER_ANISOTROPIC_16X = 5,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum TextureWrap {
TEXTURE_WRAP_REPEAT = 0,
TEXTURE_WRAP_CLAMP = 1,
TEXTURE_WRAP_MIRROR_REPEAT = 2,
TEXTURE_WRAP_MIRROR_CLAMP = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum CubemapLayout {
CUBEMAP_LAYOUT_AUTO_DETECT = 0,
CUBEMAP_LAYOUT_LINE_VERTICAL = 1,
CUBEMAP_LAYOUT_LINE_HORIZONTAL = 2,
CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR = 3,
CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE = 4,
CUBEMAP_LAYOUT_PANORAMA = 5,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum FontType {
FONT_DEFAULT = 0,
FONT_BITMAP = 1,
FONT_SDF = 2,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum BlendMode {
BLEND_ALPHA = 0,
BLEND_ADDITIVE = 1,
BLEND_MULTIPLIED = 2,
BLEND_ADD_COLORS = 3,
BLEND_SUBTRACT_COLORS = 4,
BLEND_ALPHA_PREMULTIPLY = 5,
BLEND_CUSTOM = 6,
BLEND_CUSTOM_SEPARATE = 7,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum Gesture {
GESTURE_NONE = 0,
GESTURE_TAP = 1,
GESTURE_DOUBLETAP = 2,
GESTURE_HOLD = 4,
GESTURE_DRAG = 8,
GESTURE_SWIPE_RIGHT = 16,
GESTURE_SWIPE_LEFT = 32,
GESTURE_SWIPE_UP = 64,
GESTURE_SWIPE_DOWN = 128,
GESTURE_PINCH_IN = 256,
GESTURE_PINCH_OUT = 512,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum CameraMode {
CAMERA_CUSTOM = 0,
CAMERA_FREE = 1,
CAMERA_ORBITAL = 2,
CAMERA_FIRST_PERSON = 3,
CAMERA_THIRD_PERSON = 4,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum CameraProjection {
CAMERA_PERSPECTIVE = 0,
CAMERA_ORTHOGRAPHIC = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum NPatchLayout {
NPATCH_NINE_PATCH = 0,
NPATCH_THREE_PATCH_VERTICAL = 1,
NPATCH_THREE_PATCH_HORIZONTAL = 2,
}
pub type TraceLogCallback = ::std::option::Option<
unsafe extern "C" fn(
logLevel: ::std::os::raw::c_int,
text: *const ::std::os::raw::c_char,
args: *mut __va_list_tag,
),
>;
pub type LoadFileDataCallback = ::std::option::Option<
unsafe extern "C" fn(
fileName: *const ::std::os::raw::c_char,
dataSize: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_uchar,
>;
pub type SaveFileDataCallback = ::std::option::Option<
unsafe extern "C" fn(
fileName: *const ::std::os::raw::c_char,
data: *mut ::std::os::raw::c_void,
dataSize: ::std::os::raw::c_int,
) -> bool,
>;
pub type LoadFileTextCallback = ::std::option::Option<
unsafe extern "C" fn(fileName: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char,
>;
pub type SaveFileTextCallback = ::std::option::Option<
unsafe extern "C" fn(
fileName: *const ::std::os::raw::c_char,
text: *mut ::std::os::raw::c_char,
) -> bool,
>;
extern "C" {
pub fn InitWindow(
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
title: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn CloseWindow();
}
extern "C" {
pub fn WindowShouldClose() -> bool;
}
extern "C" {
pub fn IsWindowReady() -> bool;
}
extern "C" {
pub fn IsWindowFullscreen() -> bool;
}
extern "C" {
pub fn IsWindowHidden() -> bool;
}
extern "C" {
pub fn IsWindowMinimized() -> bool;
}
extern "C" {
pub fn IsWindowMaximized() -> bool;
}
extern "C" {
pub fn IsWindowFocused() -> bool;
}
extern "C" {
pub fn IsWindowResized() -> bool;
}
extern "C" {
pub fn IsWindowState(flag: ::std::os::raw::c_uint) -> bool;
}
extern "C" {
pub fn SetWindowState(flags: ::std::os::raw::c_uint);
}
extern "C" {
pub fn ClearWindowState(flags: ::std::os::raw::c_uint);
}
extern "C" {
pub fn ToggleFullscreen();
}
extern "C" {
pub fn ToggleBorderlessWindowed();
}
extern "C" {
pub fn MaximizeWindow();
}
extern "C" {
pub fn MinimizeWindow();
}
extern "C" {
pub fn RestoreWindow();
}
extern "C" {
pub fn SetWindowIcon(image: Image);
}
extern "C" {
pub fn SetWindowIcons(images: *mut Image, count: ::std::os::raw::c_int);
}
extern "C" {
pub fn SetWindowTitle(title: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn SetWindowPosition(x: ::std::os::raw::c_int, y: ::std::os::raw::c_int);
}
extern "C" {
pub fn SetWindowMonitor(monitor: ::std::os::raw::c_int);
}
extern "C" {
pub fn SetWindowMinSize(width: ::std::os::raw::c_int, height: ::std::os::raw::c_int);
}
extern "C" {
pub fn SetWindowMaxSize(width: ::std::os::raw::c_int, height: ::std::os::raw::c_int);
}
extern "C" {
pub fn SetWindowSize(width: ::std::os::raw::c_int, height: ::std::os::raw::c_int);
}
extern "C" {
pub fn SetWindowOpacity(opacity: f32);
}
extern "C" {
pub fn SetWindowFocused();
}
extern "C" {
pub fn GetWindowHandle() -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn GetScreenWidth() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetScreenHeight() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetRenderWidth() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetRenderHeight() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetMonitorCount() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetCurrentMonitor() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetMonitorPosition(monitor: ::std::os::raw::c_int) -> Vector2;
}
extern "C" {
pub fn GetMonitorWidth(monitor: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetMonitorHeight(monitor: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetMonitorPhysicalWidth(monitor: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetMonitorPhysicalHeight(monitor: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetMonitorRefreshRate(monitor: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetWindowPosition() -> Vector2;
}
extern "C" {
pub fn GetWindowScaleDPI() -> Vector2;
}
extern "C" {
pub fn GetMonitorName(monitor: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn SetClipboardText(text: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn GetClipboardText() -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn EnableEventWaiting();
}
extern "C" {
pub fn DisableEventWaiting();
}
extern "C" {
pub fn ShowCursor();
}
extern "C" {
pub fn HideCursor();
}
extern "C" {
pub fn IsCursorHidden() -> bool;
}
extern "C" {
pub fn EnableCursor();
}
extern "C" {
pub fn DisableCursor();
}
extern "C" {
pub fn IsCursorOnScreen() -> bool;
}
extern "C" {
pub fn ClearBackground(color: Color);
}
extern "C" {
pub fn BeginDrawing();
}
extern "C" {
pub fn EndDrawing();
}
extern "C" {
pub fn BeginMode2D(camera: Camera2D);
}
extern "C" {
pub fn EndMode2D();
}
extern "C" {
pub fn BeginMode3D(camera: Camera3D);
}
extern "C" {
pub fn EndMode3D();
}
extern "C" {
pub fn BeginTextureMode(target: RenderTexture2D);
}
extern "C" {
pub fn EndTextureMode();
}
extern "C" {
pub fn BeginShaderMode(shader: Shader);
}
extern "C" {
pub fn EndShaderMode();
}
extern "C" {
pub fn BeginBlendMode(mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn EndBlendMode();
}
extern "C" {
pub fn BeginScissorMode(
x: ::std::os::raw::c_int,
y: ::std::os::raw::c_int,
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn EndScissorMode();
}
extern "C" {
pub fn BeginVrStereoMode(config: VrStereoConfig);
}
extern "C" {
pub fn EndVrStereoMode();
}
extern "C" {
pub fn LoadVrStereoConfig(device: VrDeviceInfo) -> VrStereoConfig;
}
extern "C" {
pub fn UnloadVrStereoConfig(config: VrStereoConfig);
}
extern "C" {
pub fn LoadShader(
vsFileName: *const ::std::os::raw::c_char,
fsFileName: *const ::std::os::raw::c_char,
) -> Shader;
}
extern "C" {
pub fn LoadShaderFromMemory(
vsCode: *const ::std::os::raw::c_char,
fsCode: *const ::std::os::raw::c_char,
) -> Shader;
}
extern "C" {
pub fn IsShaderReady(shader: Shader) -> bool;
}
extern "C" {
pub fn GetShaderLocation(
shader: Shader,
uniformName: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetShaderLocationAttrib(
shader: Shader,
attribName: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn SetShaderValue(
shader: Shader,
locIndex: ::std::os::raw::c_int,
value: *const ::std::os::raw::c_void,
uniformType: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn SetShaderValueV(
shader: Shader,
locIndex: ::std::os::raw::c_int,
value: *const ::std::os::raw::c_void,
uniformType: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn SetShaderValueMatrix(shader: Shader, locIndex: ::std::os::raw::c_int, mat: Matrix);
}
extern "C" {
pub fn SetShaderValueTexture(
shader: Shader,
locIndex: ::std::os::raw::c_int,
texture: Texture2D,
);
}
extern "C" {
pub fn UnloadShader(shader: Shader);
}
extern "C" {
pub fn GetMouseRay(mousePosition: Vector2, camera: Camera) -> Ray;
}
extern "C" {
pub fn GetCameraMatrix(camera: Camera) -> Matrix;
}
extern "C" {
pub fn GetCameraMatrix2D(camera: Camera2D) -> Matrix;
}
extern "C" {
pub fn GetWorldToScreen(position: Vector3, camera: Camera) -> Vector2;
}
extern "C" {
pub fn GetScreenToWorld2D(position: Vector2, camera: Camera2D) -> Vector2;
}
extern "C" {
pub fn GetWorldToScreenEx(
position: Vector3,
camera: Camera,
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
) -> Vector2;
}
extern "C" {
pub fn GetWorldToScreen2D(position: Vector2, camera: Camera2D) -> Vector2;
}
extern "C" {
pub fn SetTargetFPS(fps: ::std::os::raw::c_int);
}
extern "C" {
pub fn GetFrameTime() -> f32;
}
extern "C" {
pub fn GetTime() -> f64;
}
extern "C" {
pub fn GetFPS() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn SwapScreenBuffer();
}
extern "C" {
pub fn PollInputEvents();
}
extern "C" {
pub fn WaitTime(seconds: f64);
}
extern "C" {
pub fn SetRandomSeed(seed: ::std::os::raw::c_uint);
}
extern "C" {
pub fn GetRandomValue(
min: ::std::os::raw::c_int,
max: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn LoadRandomSequence(
count: ::std::os::raw::c_uint,
min: ::std::os::raw::c_int,
max: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn UnloadRandomSequence(sequence: *mut ::std::os::raw::c_int);
}
extern "C" {
pub fn TakeScreenshot(fileName: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn SetConfigFlags(flags: ::std::os::raw::c_uint);
}
extern "C" {
pub fn OpenURL(url: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn TraceLog(logLevel: ::std::os::raw::c_int, text: *const ::std::os::raw::c_char, ...);
}
extern "C" {
pub fn SetTraceLogLevel(logLevel: ::std::os::raw::c_int);
}
extern "C" {
pub fn MemAlloc(size: ::std::os::raw::c_uint) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn MemRealloc(
ptr: *mut ::std::os::raw::c_void,
size: ::std::os::raw::c_uint,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn MemFree(ptr: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn SetTraceLogCallback(callback: TraceLogCallback);
}
extern "C" {
pub fn SetLoadFileDataCallback(callback: LoadFileDataCallback);
}
extern "C" {
pub fn SetSaveFileDataCallback(callback: SaveFileDataCallback);
}
extern "C" {
pub fn SetLoadFileTextCallback(callback: LoadFileTextCallback);
}
extern "C" {
pub fn SetSaveFileTextCallback(callback: SaveFileTextCallback);
}
extern "C" {
pub fn LoadFileData(
fileName: *const ::std::os::raw::c_char,
dataSize: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_uchar;
}
extern "C" {
pub fn UnloadFileData(data: *mut ::std::os::raw::c_uchar);
}
extern "C" {
pub fn SaveFileData(
fileName: *const ::std::os::raw::c_char,
data: *mut ::std::os::raw::c_void,
dataSize: ::std::os::raw::c_int,
) -> bool;
}
extern "C" {
pub fn ExportDataAsCode(
data: *const ::std::os::raw::c_uchar,
dataSize: ::std::os::raw::c_int,
fileName: *const ::std::os::raw::c_char,
) -> bool;
}
extern "C" {
pub fn LoadFileText(fileName: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn UnloadFileText(text: *mut ::std::os::raw::c_char);
}
extern "C" {
pub fn SaveFileText(
fileName: *const ::std::os::raw::c_char,
text: *mut ::std::os::raw::c_char,
) -> bool;
}
extern "C" {
pub fn FileExists(fileName: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
pub fn DirectoryExists(dirPath: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
pub fn IsFileExtension(
fileName: *const ::std::os::raw::c_char,
ext: *const ::std::os::raw::c_char,
) -> bool;
}
extern "C" {
pub fn GetFileLength(fileName: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetFileExtension(
fileName: *const ::std::os::raw::c_char,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn GetFileName(filePath: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn GetFileNameWithoutExt(
filePath: *const ::std::os::raw::c_char,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn GetDirectoryPath(
filePath: *const ::std::os::raw::c_char,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn GetPrevDirectoryPath(
dirPath: *const ::std::os::raw::c_char,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn GetWorkingDirectory() -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn GetApplicationDirectory() -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn ChangeDirectory(dir: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
pub fn IsPathFile(path: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
pub fn LoadDirectoryFiles(dirPath: *const ::std::os::raw::c_char) -> FilePathList;
}
extern "C" {
pub fn LoadDirectoryFilesEx(
basePath: *const ::std::os::raw::c_char,
filter: *const ::std::os::raw::c_char,
scanSubdirs: bool,
) -> FilePathList;
}
extern "C" {
pub fn UnloadDirectoryFiles(files: FilePathList);
}
extern "C" {
pub fn IsFileDropped() -> bool;
}
extern "C" {
pub fn LoadDroppedFiles() -> FilePathList;
}
extern "C" {
pub fn UnloadDroppedFiles(files: FilePathList);
}
extern "C" {
pub fn GetFileModTime(fileName: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn CompressData(
data: *const ::std::os::raw::c_uchar,
dataSize: ::std::os::raw::c_int,
compDataSize: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_uchar;
}
extern "C" {
pub fn DecompressData(
compData: *const ::std::os::raw::c_uchar,
compDataSize: ::std::os::raw::c_int,
dataSize: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_uchar;
}
extern "C" {
pub fn EncodeDataBase64(
data: *const ::std::os::raw::c_uchar,
dataSize: ::std::os::raw::c_int,
outputSize: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn DecodeDataBase64(
data: *const ::std::os::raw::c_uchar,
outputSize: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_uchar;
}
extern "C" {
pub fn LoadAutomationEventList(fileName: *const ::std::os::raw::c_char) -> AutomationEventList;
}
extern "C" {
pub fn UnloadAutomationEventList(list: *mut AutomationEventList);
}
extern "C" {
pub fn ExportAutomationEventList(
list: AutomationEventList,
fileName: *const ::std::os::raw::c_char,
) -> bool;
}
extern "C" {
pub fn SetAutomationEventList(list: *mut AutomationEventList);
}
extern "C" {
pub fn SetAutomationEventBaseFrame(frame: ::std::os::raw::c_int);
}
extern "C" {
pub fn StartAutomationEventRecording();
}
extern "C" {
pub fn StopAutomationEventRecording();
}
extern "C" {
pub fn PlayAutomationEvent(event: AutomationEvent);
}
extern "C" {
pub fn IsKeyPressed(key: ::std::os::raw::c_int) -> bool;
}
extern "C" {
pub fn IsKeyPressedRepeat(key: ::std::os::raw::c_int) -> bool;
}
extern "C" {
pub fn IsKeyDown(key: ::std::os::raw::c_int) -> bool;
}
extern "C" {
pub fn IsKeyReleased(key: ::std::os::raw::c_int) -> bool;
}
extern "C" {
pub fn IsKeyUp(key: ::std::os::raw::c_int) -> bool;
}
extern "C" {
pub fn GetKeyPressed() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetCharPressed() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn SetExitKey(key: ::std::os::raw::c_int);
}
extern "C" {
pub fn IsGamepadAvailable(gamepad: ::std::os::raw::c_int) -> bool;
}
extern "C" {
pub fn GetGamepadName(gamepad: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn IsGamepadButtonPressed(
gamepad: ::std::os::raw::c_int,
button: ::std::os::raw::c_int,
) -> bool;
}
extern "C" {
pub fn IsGamepadButtonDown(
gamepad: ::std::os::raw::c_int,
button: ::std::os::raw::c_int,
) -> bool;
}
extern "C" {
pub fn IsGamepadButtonReleased(
gamepad: ::std::os::raw::c_int,
button: ::std::os::raw::c_int,
) -> bool;
}
extern "C" {
pub fn IsGamepadButtonUp(gamepad: ::std::os::raw::c_int, button: ::std::os::raw::c_int)
-> bool;
}
extern "C" {
pub fn GetGamepadButtonPressed() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetGamepadAxisCount(gamepad: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetGamepadAxisMovement(
gamepad: ::std::os::raw::c_int,
axis: ::std::os::raw::c_int,
) -> f32;
}
extern "C" {
pub fn SetGamepadMappings(mappings: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn IsMouseButtonPressed(button: ::std::os::raw::c_int) -> bool;
}
extern "C" {
pub fn IsMouseButtonDown(button: ::std::os::raw::c_int) -> bool;
}
extern "C" {
pub fn IsMouseButtonReleased(button: ::std::os::raw::c_int) -> bool;
}
extern "C" {
pub fn IsMouseButtonUp(button: ::std::os::raw::c_int) -> bool;
}
extern "C" {
pub fn GetMouseX() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetMouseY() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetMousePosition() -> Vector2;
}
extern "C" {
pub fn GetMouseDelta() -> Vector2;
}
extern "C" {
pub fn SetMousePosition(x: ::std::os::raw::c_int, y: ::std::os::raw::c_int);
}
extern "C" {
pub fn SetMouseOffset(offsetX: ::std::os::raw::c_int, offsetY: ::std::os::raw::c_int);
}
extern "C" {
pub fn SetMouseScale(scaleX: f32, scaleY: f32);
}
extern "C" {
pub fn GetMouseWheelMove() -> f32;
}
extern "C" {
pub fn GetMouseWheelMoveV() -> Vector2;
}
extern "C" {
pub fn SetMouseCursor(cursor: ::std::os::raw::c_int);
}
extern "C" {
pub fn GetTouchX() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetTouchY() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetTouchPosition(index: ::std::os::raw::c_int) -> Vector2;
}
extern "C" {
pub fn GetTouchPointId(index: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetTouchPointCount() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn SetGesturesEnabled(flags: ::std::os::raw::c_uint);
}
extern "C" {
pub fn IsGestureDetected(gesture: ::std::os::raw::c_uint) -> bool;
}
extern "C" {
pub fn GetGestureDetected() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetGestureHoldDuration() -> f32;
}
extern "C" {
pub fn GetGestureDragVector() -> Vector2;
}
extern "C" {
pub fn GetGestureDragAngle() -> f32;
}
extern "C" {
pub fn GetGesturePinchVector() -> Vector2;
}
extern "C" {
pub fn GetGesturePinchAngle() -> f32;
}
extern "C" {
pub fn UpdateCamera(camera: *mut Camera, mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn UpdateCameraPro(camera: *mut Camera, movement: Vector3, rotation: Vector3, zoom: f32);
}
extern "C" {
pub fn SetShapesTexture(texture: Texture2D, source: Rectangle);
}
extern "C" {
pub fn DrawPixel(posX: ::std::os::raw::c_int, posY: ::std::os::raw::c_int, color: Color);
}
extern "C" {
pub fn DrawPixelV(position: Vector2, color: Color);
}
extern "C" {
pub fn DrawLine(
startPosX: ::std::os::raw::c_int,
startPosY: ::std::os::raw::c_int,
endPosX: ::std::os::raw::c_int,
endPosY: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawLineV(startPos: Vector2, endPos: Vector2, color: Color);
}
extern "C" {
pub fn DrawLineEx(startPos: Vector2, endPos: Vector2, thick: f32, color: Color);
}
extern "C" {
pub fn DrawLineStrip(points: *mut Vector2, pointCount: ::std::os::raw::c_int, color: Color);
}
extern "C" {
pub fn DrawLineBezier(startPos: Vector2, endPos: Vector2, thick: f32, color: Color);
}
extern "C" {
pub fn DrawCircle(
centerX: ::std::os::raw::c_int,
centerY: ::std::os::raw::c_int,
radius: f32,
color: Color,
);
}
extern "C" {
pub fn DrawCircleSector(
center: Vector2,
radius: f32,
startAngle: f32,
endAngle: f32,
segments: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawCircleSectorLines(
center: Vector2,
radius: f32,
startAngle: f32,
endAngle: f32,
segments: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawCircleGradient(
centerX: ::std::os::raw::c_int,
centerY: ::std::os::raw::c_int,
radius: f32,
color1: Color,
color2: Color,
);
}
extern "C" {
pub fn DrawCircleV(center: Vector2, radius: f32, color: Color);
}
extern "C" {
pub fn DrawCircleLines(
centerX: ::std::os::raw::c_int,
centerY: ::std::os::raw::c_int,
radius: f32,
color: Color,
);
}
extern "C" {
pub fn DrawCircleLinesV(center: Vector2, radius: f32, color: Color);
}
extern "C" {
pub fn DrawEllipse(
centerX: ::std::os::raw::c_int,
centerY: ::std::os::raw::c_int,
radiusH: f32,
radiusV: f32,
color: Color,
);
}
extern "C" {
pub fn DrawEllipseLines(
centerX: ::std::os::raw::c_int,
centerY: ::std::os::raw::c_int,
radiusH: f32,
radiusV: f32,
color: Color,
);
}
extern "C" {
pub fn DrawRing(
center: Vector2,
innerRadius: f32,
outerRadius: f32,
startAngle: f32,
endAngle: f32,
segments: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawRingLines(
center: Vector2,
innerRadius: f32,
outerRadius: f32,
startAngle: f32,
endAngle: f32,
segments: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawRectangle(
posX: ::std::os::raw::c_int,
posY: ::std::os::raw::c_int,
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawRectangleV(position: Vector2, size: Vector2, color: Color);
}
extern "C" {
pub fn DrawRectangleRec(rec: Rectangle, color: Color);
}
extern "C" {
pub fn DrawRectanglePro(rec: Rectangle, origin: Vector2, rotation: f32, color: Color);
}
extern "C" {
pub fn DrawRectangleGradientV(
posX: ::std::os::raw::c_int,
posY: ::std::os::raw::c_int,
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
color1: Color,
color2: Color,
);
}
extern "C" {
pub fn DrawRectangleGradientH(
posX: ::std::os::raw::c_int,
posY: ::std::os::raw::c_int,
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
color1: Color,
color2: Color,
);
}
extern "C" {
pub fn DrawRectangleGradientEx(
rec: Rectangle,
col1: Color,
col2: Color,
col3: Color,
col4: Color,
);
}
extern "C" {
pub fn DrawRectangleLines(
posX: ::std::os::raw::c_int,
posY: ::std::os::raw::c_int,
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawRectangleLinesEx(rec: Rectangle, lineThick: f32, color: Color);
}
extern "C" {
pub fn DrawRectangleRounded(
rec: Rectangle,
roundness: f32,
segments: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawRectangleRoundedLines(
rec: Rectangle,
roundness: f32,
segments: ::std::os::raw::c_int,
lineThick: f32,
color: Color,
);
}
extern "C" {
pub fn DrawTriangle(v1: Vector2, v2: Vector2, v3: Vector2, color: Color);
}
extern "C" {
pub fn DrawTriangleLines(v1: Vector2, v2: Vector2, v3: Vector2, color: Color);
}
extern "C" {
pub fn DrawTriangleFan(points: *mut Vector2, pointCount: ::std::os::raw::c_int, color: Color);
}
extern "C" {
pub fn DrawTriangleStrip(points: *mut Vector2, pointCount: ::std::os::raw::c_int, color: Color);
}
extern "C" {
pub fn DrawPoly(
center: Vector2,
sides: ::std::os::raw::c_int,
radius: f32,
rotation: f32,
color: Color,
);
}
extern "C" {
pub fn DrawPolyLines(
center: Vector2,
sides: ::std::os::raw::c_int,
radius: f32,
rotation: f32,
color: Color,
);
}
extern "C" {
pub fn DrawPolyLinesEx(
center: Vector2,
sides: ::std::os::raw::c_int,
radius: f32,
rotation: f32,
lineThick: f32,
color: Color,
);
}
extern "C" {
pub fn DrawSplineLinear(
points: *mut Vector2,
pointCount: ::std::os::raw::c_int,
thick: f32,
color: Color,
);
}
extern "C" {
pub fn DrawSplineBasis(
points: *mut Vector2,
pointCount: ::std::os::raw::c_int,
thick: f32,
color: Color,
);
}
extern "C" {
pub fn DrawSplineCatmullRom(
points: *mut Vector2,
pointCount: ::std::os::raw::c_int,
thick: f32,
color: Color,
);
}
extern "C" {
pub fn DrawSplineBezierQuadratic(
points: *mut Vector2,
pointCount: ::std::os::raw::c_int,
thick: f32,
color: Color,
);
}
extern "C" {
pub fn DrawSplineBezierCubic(
points: *mut Vector2,
pointCount: ::std::os::raw::c_int,
thick: f32,
color: Color,
);
}
extern "C" {
pub fn DrawSplineSegmentLinear(p1: Vector2, p2: Vector2, thick: f32, color: Color);
}
extern "C" {
pub fn DrawSplineSegmentBasis(
p1: Vector2,
p2: Vector2,
p3: Vector2,
p4: Vector2,
thick: f32,
color: Color,
);
}
extern "C" {
pub fn DrawSplineSegmentCatmullRom(
p1: Vector2,
p2: Vector2,
p3: Vector2,
p4: Vector2,
thick: f32,
color: Color,
);
}
extern "C" {
pub fn DrawSplineSegmentBezierQuadratic(
p1: Vector2,
c2: Vector2,
p3: Vector2,
thick: f32,
color: Color,
);
}
extern "C" {
pub fn DrawSplineSegmentBezierCubic(
p1: Vector2,
c2: Vector2,
c3: Vector2,
p4: Vector2,
thick: f32,
color: Color,
);
}
extern "C" {
pub fn GetSplinePointLinear(startPos: Vector2, endPos: Vector2, t: f32) -> Vector2;
}
extern "C" {
pub fn GetSplinePointBasis(
p1: Vector2,
p2: Vector2,
p3: Vector2,
p4: Vector2,
t: f32,
) -> Vector2;
}
extern "C" {
pub fn GetSplinePointCatmullRom(
p1: Vector2,
p2: Vector2,
p3: Vector2,
p4: Vector2,
t: f32,
) -> Vector2;
}
extern "C" {
pub fn GetSplinePointBezierQuad(p1: Vector2, c2: Vector2, p3: Vector2, t: f32) -> Vector2;
}
extern "C" {
pub fn GetSplinePointBezierCubic(
p1: Vector2,
c2: Vector2,
c3: Vector2,
p4: Vector2,
t: f32,
) -> Vector2;
}
extern "C" {
pub fn CheckCollisionRecs(rec1: Rectangle, rec2: Rectangle) -> bool;
}
extern "C" {
pub fn CheckCollisionCircles(
center1: Vector2,
radius1: f32,
center2: Vector2,
radius2: f32,
) -> bool;
}
extern "C" {
pub fn CheckCollisionCircleRec(center: Vector2, radius: f32, rec: Rectangle) -> bool;
}
extern "C" {
pub fn CheckCollisionPointRec(point: Vector2, rec: Rectangle) -> bool;
}
extern "C" {
pub fn CheckCollisionPointCircle(point: Vector2, center: Vector2, radius: f32) -> bool;
}
extern "C" {
pub fn CheckCollisionPointTriangle(
point: Vector2,
p1: Vector2,
p2: Vector2,
p3: Vector2,
) -> bool;
}
extern "C" {
pub fn CheckCollisionPointPoly(
point: Vector2,
points: *mut Vector2,
pointCount: ::std::os::raw::c_int,
) -> bool;
}
extern "C" {
pub fn CheckCollisionLines(
startPos1: Vector2,
endPos1: Vector2,
startPos2: Vector2,
endPos2: Vector2,
collisionPoint: *mut Vector2,
) -> bool;
}
extern "C" {
pub fn CheckCollisionPointLine(
point: Vector2,
p1: Vector2,
p2: Vector2,
threshold: ::std::os::raw::c_int,
) -> bool;
}
extern "C" {
pub fn GetCollisionRec(rec1: Rectangle, rec2: Rectangle) -> Rectangle;
}
extern "C" {
pub fn LoadImage(fileName: *const ::std::os::raw::c_char) -> Image;
}
extern "C" {
pub fn LoadImageRaw(
fileName: *const ::std::os::raw::c_char,
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
format: ::std::os::raw::c_int,
headerSize: ::std::os::raw::c_int,
) -> Image;
}
extern "C" {
pub fn LoadImageSvg(
fileNameOrString: *const ::std::os::raw::c_char,
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
) -> Image;
}
extern "C" {
pub fn LoadImageAnim(
fileName: *const ::std::os::raw::c_char,
frames: *mut ::std::os::raw::c_int,
) -> Image;
}
extern "C" {
pub fn LoadImageFromMemory(
fileType: *const ::std::os::raw::c_char,
fileData: *const ::std::os::raw::c_uchar,
dataSize: ::std::os::raw::c_int,
) -> Image;
}
extern "C" {
pub fn LoadImageFromTexture(texture: Texture2D) -> Image;
}
extern "C" {
pub fn LoadImageFromScreen() -> Image;
}
extern "C" {
pub fn IsImageReady(image: Image) -> bool;
}
extern "C" {
pub fn UnloadImage(image: Image);
}
extern "C" {
pub fn ExportImage(image: Image, fileName: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
pub fn ExportImageToMemory(
image: Image,
fileType: *const ::std::os::raw::c_char,
fileSize: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_uchar;
}
extern "C" {
pub fn ExportImageAsCode(image: Image, fileName: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
pub fn GenImageColor(
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
color: Color,
) -> Image;
}
extern "C" {
pub fn GenImageGradientLinear(
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
direction: ::std::os::raw::c_int,
start: Color,
end: Color,
) -> Image;
}
extern "C" {
pub fn GenImageGradientRadial(
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
density: f32,
inner: Color,
outer: Color,
) -> Image;
}
extern "C" {
pub fn GenImageGradientSquare(
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
density: f32,
inner: Color,
outer: Color,
) -> Image;
}
extern "C" {
pub fn GenImageChecked(
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
checksX: ::std::os::raw::c_int,
checksY: ::std::os::raw::c_int,
col1: Color,
col2: Color,
) -> Image;
}
extern "C" {
pub fn GenImageWhiteNoise(
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
factor: f32,
) -> Image;
}
extern "C" {
pub fn GenImagePerlinNoise(
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
offsetX: ::std::os::raw::c_int,
offsetY: ::std::os::raw::c_int,
scale: f32,
) -> Image;
}
extern "C" {
pub fn GenImageCellular(
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
tileSize: ::std::os::raw::c_int,
) -> Image;
}
extern "C" {
pub fn GenImageText(
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
text: *const ::std::os::raw::c_char,
) -> Image;
}
extern "C" {
pub fn ImageCopy(image: Image) -> Image;
}
extern "C" {
pub fn ImageFromImage(image: Image, rec: Rectangle) -> Image;
}
extern "C" {
pub fn ImageText(
text: *const ::std::os::raw::c_char,
fontSize: ::std::os::raw::c_int,
color: Color,
) -> Image;
}
extern "C" {
pub fn ImageTextEx(
font: Font,
text: *const ::std::os::raw::c_char,
fontSize: f32,
spacing: f32,
tint: Color,
) -> Image;
}
extern "C" {
pub fn ImageFormat(image: *mut Image, newFormat: ::std::os::raw::c_int);
}
extern "C" {
pub fn ImageToPOT(image: *mut Image, fill: Color);
}
extern "C" {
pub fn ImageCrop(image: *mut Image, crop: Rectangle);
}
extern "C" {
pub fn ImageAlphaCrop(image: *mut Image, threshold: f32);
}
extern "C" {
pub fn ImageAlphaClear(image: *mut Image, color: Color, threshold: f32);
}
extern "C" {
pub fn ImageAlphaMask(image: *mut Image, alphaMask: Image);
}
extern "C" {
pub fn ImageAlphaPremultiply(image: *mut Image);
}
extern "C" {
pub fn ImageBlurGaussian(image: *mut Image, blurSize: ::std::os::raw::c_int);
}
extern "C" {
pub fn ImageResize(
image: *mut Image,
newWidth: ::std::os::raw::c_int,
newHeight: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn ImageResizeNN(
image: *mut Image,
newWidth: ::std::os::raw::c_int,
newHeight: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn ImageResizeCanvas(
image: *mut Image,
newWidth: ::std::os::raw::c_int,
newHeight: ::std::os::raw::c_int,
offsetX: ::std::os::raw::c_int,
offsetY: ::std::os::raw::c_int,
fill: Color,
);
}
extern "C" {
pub fn ImageMipmaps(image: *mut Image);
}
extern "C" {
pub fn ImageDither(
image: *mut Image,
rBpp: ::std::os::raw::c_int,
gBpp: ::std::os::raw::c_int,
bBpp: ::std::os::raw::c_int,
aBpp: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn ImageFlipVertical(image: *mut Image);
}
extern "C" {
pub fn ImageFlipHorizontal(image: *mut Image);
}
extern "C" {
pub fn ImageRotate(image: *mut Image, degrees: ::std::os::raw::c_int);
}
extern "C" {
pub fn ImageRotateCW(image: *mut Image);
}
extern "C" {
pub fn ImageRotateCCW(image: *mut Image);
}
extern "C" {
pub fn ImageColorTint(image: *mut Image, color: Color);
}
extern "C" {
pub fn ImageColorInvert(image: *mut Image);
}
extern "C" {
pub fn ImageColorGrayscale(image: *mut Image);
}
extern "C" {
pub fn ImageColorContrast(image: *mut Image, contrast: f32);
}
extern "C" {
pub fn ImageColorBrightness(image: *mut Image, brightness: ::std::os::raw::c_int);
}
extern "C" {
pub fn ImageColorReplace(image: *mut Image, color: Color, replace: Color);
}
extern "C" {
pub fn LoadImageColors(image: Image) -> *mut Color;
}
extern "C" {
pub fn LoadImagePalette(
image: Image,
maxPaletteSize: ::std::os::raw::c_int,
colorCount: *mut ::std::os::raw::c_int,
) -> *mut Color;
}
extern "C" {
pub fn UnloadImageColors(colors: *mut Color);
}
extern "C" {
pub fn UnloadImagePalette(colors: *mut Color);
}
extern "C" {
pub fn GetImageAlphaBorder(image: Image, threshold: f32) -> Rectangle;
}
extern "C" {
pub fn GetImageColor(image: Image, x: ::std::os::raw::c_int, y: ::std::os::raw::c_int)
-> Color;
}
extern "C" {
pub fn ImageClearBackground(dst: *mut Image, color: Color);
}
extern "C" {
pub fn ImageDrawPixel(
dst: *mut Image,
posX: ::std::os::raw::c_int,
posY: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn ImageDrawPixelV(dst: *mut Image, position: Vector2, color: Color);
}
extern "C" {
pub fn ImageDrawLine(
dst: *mut Image,
startPosX: ::std::os::raw::c_int,
startPosY: ::std::os::raw::c_int,
endPosX: ::std::os::raw::c_int,
endPosY: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn ImageDrawLineV(dst: *mut Image, start: Vector2, end: Vector2, color: Color);
}
extern "C" {
pub fn ImageDrawCircle(
dst: *mut Image,
centerX: ::std::os::raw::c_int,
centerY: ::std::os::raw::c_int,
radius: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn ImageDrawCircleV(
dst: *mut Image,
center: Vector2,
radius: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn ImageDrawCircleLines(
dst: *mut Image,
centerX: ::std::os::raw::c_int,
centerY: ::std::os::raw::c_int,
radius: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn ImageDrawCircleLinesV(
dst: *mut Image,
center: Vector2,
radius: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn ImageDrawRectangle(
dst: *mut Image,
posX: ::std::os::raw::c_int,
posY: ::std::os::raw::c_int,
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn ImageDrawRectangleV(dst: *mut Image, position: Vector2, size: Vector2, color: Color);
}
extern "C" {
pub fn ImageDrawRectangleRec(dst: *mut Image, rec: Rectangle, color: Color);
}
extern "C" {
pub fn ImageDrawRectangleLines(
dst: *mut Image,
rec: Rectangle,
thick: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn ImageDraw(
dst: *mut Image,
src: Image,
srcRec: Rectangle,
dstRec: Rectangle,
tint: Color,
);
}
extern "C" {
pub fn ImageDrawText(
dst: *mut Image,
text: *const ::std::os::raw::c_char,
posX: ::std::os::raw::c_int,
posY: ::std::os::raw::c_int,
fontSize: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn ImageDrawTextEx(
dst: *mut Image,
font: Font,
text: *const ::std::os::raw::c_char,
position: Vector2,
fontSize: f32,
spacing: f32,
tint: Color,
);
}
extern "C" {
pub fn LoadTexture(fileName: *const ::std::os::raw::c_char) -> Texture2D;
}
extern "C" {
pub fn LoadTextureFromImage(image: Image) -> Texture2D;
}
extern "C" {
pub fn LoadTextureCubemap(image: Image, layout: ::std::os::raw::c_int) -> TextureCubemap;
}
extern "C" {
pub fn LoadRenderTexture(
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
) -> RenderTexture2D;
}
extern "C" {
pub fn IsTextureReady(texture: Texture2D) -> bool;
}
extern "C" {
pub fn UnloadTexture(texture: Texture2D);
}
extern "C" {
pub fn IsRenderTextureReady(target: RenderTexture2D) -> bool;
}
extern "C" {
pub fn UnloadRenderTexture(target: RenderTexture2D);
}
extern "C" {
pub fn UpdateTexture(texture: Texture2D, pixels: *const ::std::os::raw::c_void);
}
extern "C" {
pub fn UpdateTextureRec(
texture: Texture2D,
rec: Rectangle,
pixels: *const ::std::os::raw::c_void,
);
}
extern "C" {
pub fn GenTextureMipmaps(texture: *mut Texture2D);
}
extern "C" {
pub fn SetTextureFilter(texture: Texture2D, filter: ::std::os::raw::c_int);
}
extern "C" {
pub fn SetTextureWrap(texture: Texture2D, wrap: ::std::os::raw::c_int);
}
extern "C" {
pub fn DrawTexture(
texture: Texture2D,
posX: ::std::os::raw::c_int,
posY: ::std::os::raw::c_int,
tint: Color,
);
}
extern "C" {
pub fn DrawTextureV(texture: Texture2D, position: Vector2, tint: Color);
}
extern "C" {
pub fn DrawTextureEx(
texture: Texture2D,
position: Vector2,
rotation: f32,
scale: f32,
tint: Color,
);
}
extern "C" {
pub fn DrawTextureRec(texture: Texture2D, source: Rectangle, position: Vector2, tint: Color);
}
extern "C" {
pub fn DrawTexturePro(
texture: Texture2D,
source: Rectangle,
dest: Rectangle,
origin: Vector2,
rotation: f32,
tint: Color,
);
}
extern "C" {
pub fn DrawTextureNPatch(
texture: Texture2D,
nPatchInfo: NPatchInfo,
dest: Rectangle,
origin: Vector2,
rotation: f32,
tint: Color,
);
}
extern "C" {
pub fn Fade(color: Color, alpha: f32) -> Color;
}
extern "C" {
pub fn ColorToInt(color: Color) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ColorNormalize(color: Color) -> Vector4;
}
extern "C" {
pub fn ColorFromNormalized(normalized: Vector4) -> Color;
}
extern "C" {
pub fn ColorToHSV(color: Color) -> Vector3;
}
extern "C" {
pub fn ColorFromHSV(hue: f32, saturation: f32, value: f32) -> Color;
}
extern "C" {
pub fn ColorTint(color: Color, tint: Color) -> Color;
}
extern "C" {
pub fn ColorBrightness(color: Color, factor: f32) -> Color;
}
extern "C" {
pub fn ColorContrast(color: Color, contrast: f32) -> Color;
}
extern "C" {
pub fn ColorAlpha(color: Color, alpha: f32) -> Color;
}
extern "C" {
pub fn ColorAlphaBlend(dst: Color, src: Color, tint: Color) -> Color;
}
extern "C" {
pub fn GetColor(hexValue: ::std::os::raw::c_uint) -> Color;
}
extern "C" {
pub fn GetPixelColor(
srcPtr: *mut ::std::os::raw::c_void,
format: ::std::os::raw::c_int,
) -> Color;
}
extern "C" {
pub fn SetPixelColor(
dstPtr: *mut ::std::os::raw::c_void,
color: Color,
format: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn GetPixelDataSize(
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
format: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetFontDefault() -> Font;
}
extern "C" {
pub fn LoadFont(fileName: *const ::std::os::raw::c_char) -> Font;
}
extern "C" {
pub fn LoadFontEx(
fileName: *const ::std::os::raw::c_char,
fontSize: ::std::os::raw::c_int,
codepoints: *mut ::std::os::raw::c_int,
codepointCount: ::std::os::raw::c_int,
) -> Font;
}
extern "C" {
pub fn LoadFontFromImage(image: Image, key: Color, firstChar: ::std::os::raw::c_int) -> Font;
}
extern "C" {
pub fn LoadFontFromMemory(
fileType: *const ::std::os::raw::c_char,
fileData: *const ::std::os::raw::c_uchar,
dataSize: ::std::os::raw::c_int,
fontSize: ::std::os::raw::c_int,
codepoints: *mut ::std::os::raw::c_int,
codepointCount: ::std::os::raw::c_int,
) -> Font;
}
extern "C" {
pub fn IsFontReady(font: Font) -> bool;
}
extern "C" {
pub fn LoadFontData(
fileData: *const ::std::os::raw::c_uchar,
dataSize: ::std::os::raw::c_int,
fontSize: ::std::os::raw::c_int,
codepoints: *mut ::std::os::raw::c_int,
codepointCount: ::std::os::raw::c_int,
type_: ::std::os::raw::c_int,
) -> *mut GlyphInfo;
}
extern "C" {
pub fn GenImageFontAtlas(
glyphs: *const GlyphInfo,
glyphRecs: *mut *mut Rectangle,
glyphCount: ::std::os::raw::c_int,
fontSize: ::std::os::raw::c_int,
padding: ::std::os::raw::c_int,
packMethod: ::std::os::raw::c_int,
) -> Image;
}
extern "C" {
pub fn UnloadFontData(glyphs: *mut GlyphInfo, glyphCount: ::std::os::raw::c_int);
}
extern "C" {
pub fn UnloadFont(font: Font);
}
extern "C" {
pub fn ExportFontAsCode(font: Font, fileName: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
pub fn DrawFPS(posX: ::std::os::raw::c_int, posY: ::std::os::raw::c_int);
}
extern "C" {
pub fn DrawText(
text: *const ::std::os::raw::c_char,
posX: ::std::os::raw::c_int,
posY: ::std::os::raw::c_int,
fontSize: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawTextEx(
font: Font,
text: *const ::std::os::raw::c_char,
position: Vector2,
fontSize: f32,
spacing: f32,
tint: Color,
);
}
extern "C" {
pub fn DrawTextPro(
font: Font,
text: *const ::std::os::raw::c_char,
position: Vector2,
origin: Vector2,
rotation: f32,
fontSize: f32,
spacing: f32,
tint: Color,
);
}
extern "C" {
pub fn DrawTextCodepoint(
font: Font,
codepoint: ::std::os::raw::c_int,
position: Vector2,
fontSize: f32,
tint: Color,
);
}
extern "C" {
pub fn DrawTextCodepoints(
font: Font,
codepoints: *const ::std::os::raw::c_int,
codepointCount: ::std::os::raw::c_int,
position: Vector2,
fontSize: f32,
spacing: f32,
tint: Color,
);
}
extern "C" {
pub fn SetTextLineSpacing(spacing: ::std::os::raw::c_int);
}
extern "C" {
pub fn MeasureText(
text: *const ::std::os::raw::c_char,
fontSize: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MeasureTextEx(
font: Font,
text: *const ::std::os::raw::c_char,
fontSize: f32,
spacing: f32,
) -> Vector2;
}
extern "C" {
pub fn GetGlyphIndex(font: Font, codepoint: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetGlyphInfo(font: Font, codepoint: ::std::os::raw::c_int) -> GlyphInfo;
}
extern "C" {
pub fn GetGlyphAtlasRec(font: Font, codepoint: ::std::os::raw::c_int) -> Rectangle;
}
extern "C" {
pub fn LoadUTF8(
codepoints: *const ::std::os::raw::c_int,
length: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn UnloadUTF8(text: *mut ::std::os::raw::c_char);
}
extern "C" {
pub fn LoadCodepoints(
text: *const ::std::os::raw::c_char,
count: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn UnloadCodepoints(codepoints: *mut ::std::os::raw::c_int);
}
extern "C" {
pub fn GetCodepointCount(text: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetCodepoint(
text: *const ::std::os::raw::c_char,
codepointSize: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetCodepointNext(
text: *const ::std::os::raw::c_char,
codepointSize: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GetCodepointPrevious(
text: *const ::std::os::raw::c_char,
codepointSize: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn CodepointToUTF8(
codepoint: ::std::os::raw::c_int,
utf8Size: *mut ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn TextCopy(
dst: *mut ::std::os::raw::c_char,
src: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn TextIsEqual(
text1: *const ::std::os::raw::c_char,
text2: *const ::std::os::raw::c_char,
) -> bool;
}
extern "C" {
pub fn TextLength(text: *const ::std::os::raw::c_char) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn TextFormat(text: *const ::std::os::raw::c_char, ...) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn TextSubtext(
text: *const ::std::os::raw::c_char,
position: ::std::os::raw::c_int,
length: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn TextReplace(
text: *mut ::std::os::raw::c_char,
replace: *const ::std::os::raw::c_char,
by: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn TextInsert(
text: *const ::std::os::raw::c_char,
insert: *const ::std::os::raw::c_char,
position: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn TextJoin(
textList: *mut *const ::std::os::raw::c_char,
count: ::std::os::raw::c_int,
delimiter: *const ::std::os::raw::c_char,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn TextSplit(
text: *const ::std::os::raw::c_char,
delimiter: ::std::os::raw::c_char,
count: *mut ::std::os::raw::c_int,
) -> *mut *const ::std::os::raw::c_char;
}
extern "C" {
pub fn TextAppend(
text: *mut ::std::os::raw::c_char,
append: *const ::std::os::raw::c_char,
position: *mut ::std::os::raw::c_int,
);
}
extern "C" {
pub fn TextFindIndex(
text: *const ::std::os::raw::c_char,
find: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn TextToUpper(text: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn TextToLower(text: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn TextToPascal(text: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn TextToInteger(text: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn DrawLine3D(startPos: Vector3, endPos: Vector3, color: Color);
}
extern "C" {
pub fn DrawPoint3D(position: Vector3, color: Color);
}
extern "C" {
pub fn DrawCircle3D(
center: Vector3,
radius: f32,
rotationAxis: Vector3,
rotationAngle: f32,
color: Color,
);
}
extern "C" {
pub fn DrawTriangle3D(v1: Vector3, v2: Vector3, v3: Vector3, color: Color);
}
extern "C" {
pub fn DrawTriangleStrip3D(
points: *mut Vector3,
pointCount: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawCube(position: Vector3, width: f32, height: f32, length: f32, color: Color);
}
extern "C" {
pub fn DrawCubeV(position: Vector3, size: Vector3, color: Color);
}
extern "C" {
pub fn DrawCubeWires(position: Vector3, width: f32, height: f32, length: f32, color: Color);
}
extern "C" {
pub fn DrawCubeWiresV(position: Vector3, size: Vector3, color: Color);
}
extern "C" {
pub fn DrawSphere(centerPos: Vector3, radius: f32, color: Color);
}
extern "C" {
pub fn DrawSphereEx(
centerPos: Vector3,
radius: f32,
rings: ::std::os::raw::c_int,
slices: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawSphereWires(
centerPos: Vector3,
radius: f32,
rings: ::std::os::raw::c_int,
slices: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawCylinder(
position: Vector3,
radiusTop: f32,
radiusBottom: f32,
height: f32,
slices: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawCylinderEx(
startPos: Vector3,
endPos: Vector3,
startRadius: f32,
endRadius: f32,
sides: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawCylinderWires(
position: Vector3,
radiusTop: f32,
radiusBottom: f32,
height: f32,
slices: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawCylinderWiresEx(
startPos: Vector3,
endPos: Vector3,
startRadius: f32,
endRadius: f32,
sides: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawCapsule(
startPos: Vector3,
endPos: Vector3,
radius: f32,
slices: ::std::os::raw::c_int,
rings: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawCapsuleWires(
startPos: Vector3,
endPos: Vector3,
radius: f32,
slices: ::std::os::raw::c_int,
rings: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn DrawPlane(centerPos: Vector3, size: Vector2, color: Color);
}
extern "C" {
pub fn DrawRay(ray: Ray, color: Color);
}
extern "C" {
pub fn DrawGrid(slices: ::std::os::raw::c_int, spacing: f32);
}
extern "C" {
pub fn LoadModel(fileName: *const ::std::os::raw::c_char) -> Model;
}
extern "C" {
pub fn LoadModelFromMesh(mesh: Mesh) -> Model;
}
extern "C" {
pub fn IsModelReady(model: Model) -> bool;
}
extern "C" {
pub fn UnloadModel(model: Model);
}
extern "C" {
pub fn GetModelBoundingBox(model: Model) -> BoundingBox;
}
extern "C" {
pub fn DrawModel(model: Model, position: Vector3, scale: f32, tint: Color);
}
extern "C" {
pub fn DrawModelEx(
model: Model,
position: Vector3,
rotationAxis: Vector3,
rotationAngle: f32,
scale: Vector3,
tint: Color,
);
}
extern "C" {
pub fn DrawModelWires(model: Model, position: Vector3, scale: f32, tint: Color);
}
extern "C" {
pub fn DrawModelWiresEx(
model: Model,
position: Vector3,
rotationAxis: Vector3,
rotationAngle: f32,
scale: Vector3,
tint: Color,
);
}
extern "C" {
pub fn DrawBoundingBox(box_: BoundingBox, color: Color);
}
extern "C" {
pub fn DrawBillboard(
camera: Camera,
texture: Texture2D,
position: Vector3,
size: f32,
tint: Color,
);
}
extern "C" {
pub fn DrawBillboardRec(
camera: Camera,
texture: Texture2D,
source: Rectangle,
position: Vector3,
size: Vector2,
tint: Color,
);
}
extern "C" {
pub fn DrawBillboardPro(
camera: Camera,
texture: Texture2D,
source: Rectangle,
position: Vector3,
up: Vector3,
size: Vector2,
origin: Vector2,
rotation: f32,
tint: Color,
);
}
extern "C" {
pub fn UploadMesh(mesh: *mut Mesh, dynamic: bool);
}
extern "C" {
pub fn UpdateMeshBuffer(
mesh: Mesh,
index: ::std::os::raw::c_int,
data: *const ::std::os::raw::c_void,
dataSize: ::std::os::raw::c_int,
offset: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn UnloadMesh(mesh: Mesh);
}
extern "C" {
pub fn DrawMesh(mesh: Mesh, material: Material, transform: Matrix);
}
extern "C" {
pub fn DrawMeshInstanced(
mesh: Mesh,
material: Material,
transforms: *const Matrix,
instances: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn ExportMesh(mesh: Mesh, fileName: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
pub fn GetMeshBoundingBox(mesh: Mesh) -> BoundingBox;
}
extern "C" {
pub fn GenMeshTangents(mesh: *mut Mesh);
}
extern "C" {
pub fn GenMeshPoly(sides: ::std::os::raw::c_int, radius: f32) -> Mesh;
}
extern "C" {
pub fn GenMeshPlane(
width: f32,
length: f32,
resX: ::std::os::raw::c_int,
resZ: ::std::os::raw::c_int,
) -> Mesh;
}
extern "C" {
pub fn GenMeshCube(width: f32, height: f32, length: f32) -> Mesh;
}
extern "C" {
pub fn GenMeshSphere(
radius: f32,
rings: ::std::os::raw::c_int,
slices: ::std::os::raw::c_int,
) -> Mesh;
}
extern "C" {
pub fn GenMeshHemiSphere(
radius: f32,
rings: ::std::os::raw::c_int,
slices: ::std::os::raw::c_int,
) -> Mesh;
}
extern "C" {
pub fn GenMeshCylinder(radius: f32, height: f32, slices: ::std::os::raw::c_int) -> Mesh;
}
extern "C" {
pub fn GenMeshCone(radius: f32, height: f32, slices: ::std::os::raw::c_int) -> Mesh;
}
extern "C" {
pub fn GenMeshTorus(
radius: f32,
size: f32,
radSeg: ::std::os::raw::c_int,
sides: ::std::os::raw::c_int,
) -> Mesh;
}
extern "C" {
pub fn GenMeshKnot(
radius: f32,
size: f32,
radSeg: ::std::os::raw::c_int,
sides: ::std::os::raw::c_int,
) -> Mesh;
}
extern "C" {
pub fn GenMeshHeightmap(heightmap: Image, size: Vector3) -> Mesh;
}
extern "C" {
pub fn GenMeshCubicmap(cubicmap: Image, cubeSize: Vector3) -> Mesh;
}
extern "C" {
pub fn LoadMaterials(
fileName: *const ::std::os::raw::c_char,
materialCount: *mut ::std::os::raw::c_int,
) -> *mut Material;
}
extern "C" {
pub fn LoadMaterialDefault() -> Material;
}
extern "C" {
pub fn IsMaterialReady(material: Material) -> bool;
}
extern "C" {
pub fn UnloadMaterial(material: Material);
}
extern "C" {
pub fn SetMaterialTexture(
material: *mut Material,
mapType: ::std::os::raw::c_int,
texture: Texture2D,
);
}
extern "C" {
pub fn SetModelMeshMaterial(
model: *mut Model,
meshId: ::std::os::raw::c_int,
materialId: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn LoadModelAnimations(
fileName: *const ::std::os::raw::c_char,
animCount: *mut ::std::os::raw::c_int,
) -> *mut ModelAnimation;
}
extern "C" {
pub fn UpdateModelAnimation(model: Model, anim: ModelAnimation, frame: ::std::os::raw::c_int);
}
extern "C" {
pub fn UnloadModelAnimation(anim: ModelAnimation);
}
extern "C" {
pub fn UnloadModelAnimations(animations: *mut ModelAnimation, animCount: ::std::os::raw::c_int);
}
extern "C" {
pub fn IsModelAnimationValid(model: Model, anim: ModelAnimation) -> bool;
}
extern "C" {
pub fn CheckCollisionSpheres(
center1: Vector3,
radius1: f32,
center2: Vector3,
radius2: f32,
) -> bool;
}
extern "C" {
pub fn CheckCollisionBoxes(box1: BoundingBox, box2: BoundingBox) -> bool;
}
extern "C" {
pub fn CheckCollisionBoxSphere(box_: BoundingBox, center: Vector3, radius: f32) -> bool;
}
extern "C" {
pub fn GetRayCollisionSphere(ray: Ray, center: Vector3, radius: f32) -> RayCollision;
}
extern "C" {
pub fn GetRayCollisionBox(ray: Ray, box_: BoundingBox) -> RayCollision;
}
extern "C" {
pub fn GetRayCollisionMesh(ray: Ray, mesh: Mesh, transform: Matrix) -> RayCollision;
}
extern "C" {
pub fn GetRayCollisionTriangle(ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3)
-> RayCollision;
}
extern "C" {
pub fn GetRayCollisionQuad(
ray: Ray,
p1: Vector3,
p2: Vector3,
p3: Vector3,
p4: Vector3,
) -> RayCollision;
}
pub type AudioCallback = ::std::option::Option<
unsafe extern "C" fn(bufferData: *mut ::std::os::raw::c_void, frames: ::std::os::raw::c_uint),
>;
extern "C" {
pub fn InitAudioDevice();
}
extern "C" {
pub fn CloseAudioDevice();
}
extern "C" {
pub fn IsAudioDeviceReady() -> bool;
}
extern "C" {
pub fn SetMasterVolume(volume: f32);
}
extern "C" {
pub fn GetMasterVolume() -> f32;
}
extern "C" {
pub fn LoadWave(fileName: *const ::std::os::raw::c_char) -> Wave;
}
extern "C" {
pub fn LoadWaveFromMemory(
fileType: *const ::std::os::raw::c_char,
fileData: *const ::std::os::raw::c_uchar,
dataSize: ::std::os::raw::c_int,
) -> Wave;
}
extern "C" {
pub fn IsWaveReady(wave: Wave) -> bool;
}
extern "C" {
pub fn LoadSound(fileName: *const ::std::os::raw::c_char) -> Sound;
}
extern "C" {
pub fn LoadSoundFromWave(wave: Wave) -> Sound;
}
extern "C" {
pub fn LoadSoundAlias(source: Sound) -> Sound;
}
extern "C" {
pub fn IsSoundReady(sound: Sound) -> bool;
}
extern "C" {
pub fn UpdateSound(
sound: Sound,
data: *const ::std::os::raw::c_void,
sampleCount: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn UnloadWave(wave: Wave);
}
extern "C" {
pub fn UnloadSound(sound: Sound);
}
extern "C" {
pub fn UnloadSoundAlias(alias: Sound);
}
extern "C" {
pub fn ExportWave(wave: Wave, fileName: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
pub fn ExportWaveAsCode(wave: Wave, fileName: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
pub fn PlaySound(sound: Sound);
}
extern "C" {
pub fn StopSound(sound: Sound);
}
extern "C" {
pub fn PauseSound(sound: Sound);
}
extern "C" {
pub fn ResumeSound(sound: Sound);
}
extern "C" {
pub fn IsSoundPlaying(sound: Sound) -> bool;
}
extern "C" {
pub fn SetSoundVolume(sound: Sound, volume: f32);
}
extern "C" {
pub fn SetSoundPitch(sound: Sound, pitch: f32);
}
extern "C" {
pub fn SetSoundPan(sound: Sound, pan: f32);
}
extern "C" {
pub fn WaveCopy(wave: Wave) -> Wave;
}
extern "C" {
pub fn WaveCrop(
wave: *mut Wave,
initSample: ::std::os::raw::c_int,
finalSample: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn WaveFormat(
wave: *mut Wave,
sampleRate: ::std::os::raw::c_int,
sampleSize: ::std::os::raw::c_int,
channels: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn LoadWaveSamples(wave: Wave) -> *mut f32;
}
extern "C" {
pub fn UnloadWaveSamples(samples: *mut f32);
}
extern "C" {
pub fn LoadMusicStream(fileName: *const ::std::os::raw::c_char) -> Music;
}
extern "C" {
pub fn LoadMusicStreamFromMemory(
fileType: *const ::std::os::raw::c_char,
data: *const ::std::os::raw::c_uchar,
dataSize: ::std::os::raw::c_int,
) -> Music;
}
extern "C" {
pub fn IsMusicReady(music: Music) -> bool;
}
extern "C" {
pub fn UnloadMusicStream(music: Music);
}
extern "C" {
pub fn PlayMusicStream(music: Music);
}
extern "C" {
pub fn IsMusicStreamPlaying(music: Music) -> bool;
}
extern "C" {
pub fn UpdateMusicStream(music: Music);
}
extern "C" {
pub fn StopMusicStream(music: Music);
}
extern "C" {
pub fn PauseMusicStream(music: Music);
}
extern "C" {
pub fn ResumeMusicStream(music: Music);
}
extern "C" {
pub fn SeekMusicStream(music: Music, position: f32);
}
extern "C" {
pub fn SetMusicVolume(music: Music, volume: f32);
}
extern "C" {
pub fn SetMusicPitch(music: Music, pitch: f32);
}
extern "C" {
pub fn SetMusicPan(music: Music, pan: f32);
}
extern "C" {
pub fn GetMusicTimeLength(music: Music) -> f32;
}
extern "C" {
pub fn GetMusicTimePlayed(music: Music) -> f32;
}
extern "C" {
pub fn LoadAudioStream(
sampleRate: ::std::os::raw::c_uint,
sampleSize: ::std::os::raw::c_uint,
channels: ::std::os::raw::c_uint,
) -> AudioStream;
}
extern "C" {
pub fn IsAudioStreamReady(stream: AudioStream) -> bool;
}
extern "C" {
pub fn UnloadAudioStream(stream: AudioStream);
}
extern "C" {
pub fn UpdateAudioStream(
stream: AudioStream,
data: *const ::std::os::raw::c_void,
frameCount: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn IsAudioStreamProcessed(stream: AudioStream) -> bool;
}
extern "C" {
pub fn PlayAudioStream(stream: AudioStream);
}
extern "C" {
pub fn PauseAudioStream(stream: AudioStream);
}
extern "C" {
pub fn ResumeAudioStream(stream: AudioStream);
}
extern "C" {
pub fn IsAudioStreamPlaying(stream: AudioStream) -> bool;
}
extern "C" {
pub fn StopAudioStream(stream: AudioStream);
}
extern "C" {
pub fn SetAudioStreamVolume(stream: AudioStream, volume: f32);
}
extern "C" {
pub fn SetAudioStreamPitch(stream: AudioStream, pitch: f32);
}
extern "C" {
pub fn SetAudioStreamPan(stream: AudioStream, pan: f32);
}
extern "C" {
pub fn SetAudioStreamBufferSizeDefault(size: ::std::os::raw::c_int);
}
extern "C" {
pub fn SetAudioStreamCallback(stream: AudioStream, callback: AudioCallback);
}
extern "C" {
pub fn AttachAudioStreamProcessor(stream: AudioStream, processor: AudioCallback);
}
extern "C" {
pub fn DetachAudioStreamProcessor(stream: AudioStream, processor: AudioCallback);
}
extern "C" {
pub fn AttachAudioMixedProcessor(processor: AudioCallback);
}
extern "C" {
pub fn DetachAudioMixedProcessor(processor: AudioCallback);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GuiStyleProp {
pub controlId: ::std::os::raw::c_ushort,
pub propertyId: ::std::os::raw::c_ushort,
pub propertyValue: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_GuiStyleProp() {
const UNINIT: ::std::mem::MaybeUninit<GuiStyleProp> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GuiStyleProp>(),
8usize,
concat!("Size of: ", stringify!(GuiStyleProp))
);
assert_eq!(
::std::mem::align_of::<GuiStyleProp>(),
4usize,
concat!("Alignment of ", stringify!(GuiStyleProp))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).controlId) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GuiStyleProp),
"::",
stringify!(controlId)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).propertyId) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(GuiStyleProp),
"::",
stringify!(propertyId)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).propertyValue) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(GuiStyleProp),
"::",
stringify!(propertyValue)
)
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiState {
STATE_NORMAL = 0,
STATE_FOCUSED = 1,
STATE_PRESSED = 2,
STATE_DISABLED = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiTextAlignment {
TEXT_ALIGN_LEFT = 0,
TEXT_ALIGN_CENTER = 1,
TEXT_ALIGN_RIGHT = 2,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiTextAlignmentVertical {
TEXT_ALIGN_TOP = 0,
TEXT_ALIGN_MIDDLE = 1,
TEXT_ALIGN_BOTTOM = 2,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiTextWrapMode {
TEXT_WRAP_NONE = 0,
TEXT_WRAP_CHAR = 1,
TEXT_WRAP_WORD = 2,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiControl {
DEFAULT = 0,
LABEL = 1,
BUTTON = 2,
TOGGLE = 3,
SLIDER = 4,
PROGRESSBAR = 5,
CHECKBOX = 6,
COMBOBOX = 7,
DROPDOWNBOX = 8,
TEXTBOX = 9,
VALUEBOX = 10,
SPINNER = 11,
LISTVIEW = 12,
COLORPICKER = 13,
SCROLLBAR = 14,
STATUSBAR = 15,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiControlProperty {
BORDER_COLOR_NORMAL = 0,
BASE_COLOR_NORMAL = 1,
TEXT_COLOR_NORMAL = 2,
BORDER_COLOR_FOCUSED = 3,
BASE_COLOR_FOCUSED = 4,
TEXT_COLOR_FOCUSED = 5,
BORDER_COLOR_PRESSED = 6,
BASE_COLOR_PRESSED = 7,
TEXT_COLOR_PRESSED = 8,
BORDER_COLOR_DISABLED = 9,
BASE_COLOR_DISABLED = 10,
TEXT_COLOR_DISABLED = 11,
BORDER_WIDTH = 12,
TEXT_PADDING = 13,
TEXT_ALIGNMENT = 14,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiDefaultProperty {
TEXT_SIZE = 16,
TEXT_SPACING = 17,
LINE_COLOR = 18,
BACKGROUND_COLOR = 19,
TEXT_LINE_SPACING = 20,
TEXT_ALIGNMENT_VERTICAL = 21,
TEXT_WRAP_MODE = 22,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiToggleProperty {
GROUP_PADDING = 16,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiSliderProperty {
SLIDER_WIDTH = 16,
SLIDER_PADDING = 17,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiProgressBarProperty {
PROGRESS_PADDING = 16,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiScrollBarProperty {
ARROWS_SIZE = 16,
ARROWS_VISIBLE = 17,
SCROLL_SLIDER_PADDING = 18,
SCROLL_SLIDER_SIZE = 19,
SCROLL_PADDING = 20,
SCROLL_SPEED = 21,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiCheckBoxProperty {
CHECK_PADDING = 16,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiComboBoxProperty {
COMBO_BUTTON_WIDTH = 16,
COMBO_BUTTON_SPACING = 17,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiDropdownBoxProperty {
ARROW_PADDING = 16,
DROPDOWN_ITEMS_SPACING = 17,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiTextBoxProperty {
TEXT_READONLY = 16,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiSpinnerProperty {
SPIN_BUTTON_WIDTH = 16,
SPIN_BUTTON_SPACING = 17,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiListViewProperty {
LIST_ITEMS_HEIGHT = 16,
LIST_ITEMS_SPACING = 17,
SCROLLBAR_WIDTH = 18,
SCROLLBAR_SIDE = 19,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiColorPickerProperty {
COLOR_SELECTOR_SIZE = 16,
HUEBAR_WIDTH = 17,
HUEBAR_PADDING = 18,
HUEBAR_SELECTOR_HEIGHT = 19,
HUEBAR_SELECTOR_OVERFLOW = 20,
}
extern "C" {
pub fn GuiEnable();
}
extern "C" {
pub fn GuiDisable();
}
extern "C" {
pub fn GuiLock();
}
extern "C" {
pub fn GuiUnlock();
}
extern "C" {
pub fn GuiIsLocked() -> bool;
}
extern "C" {
pub fn GuiSetAlpha(alpha: f32);
}
extern "C" {
pub fn GuiSetState(state: ::std::os::raw::c_int);
}
extern "C" {
pub fn GuiGetState() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiSetFont(font: Font);
}
extern "C" {
pub fn GuiGetFont() -> Font;
}
extern "C" {
pub fn GuiSetStyle(
control: ::std::os::raw::c_int,
property: ::std::os::raw::c_int,
value: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn GuiGetStyle(
control: ::std::os::raw::c_int,
property: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiLoadStyle(fileName: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn GuiLoadStyleDefault();
}
extern "C" {
pub fn GuiEnableTooltip();
}
extern "C" {
pub fn GuiDisableTooltip();
}
extern "C" {
pub fn GuiSetTooltip(tooltip: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn GuiIconText(
iconId: ::std::os::raw::c_int,
text: *const ::std::os::raw::c_char,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn GuiSetIconScale(scale: ::std::os::raw::c_int);
}
extern "C" {
pub fn GuiGetIcons() -> *mut ::std::os::raw::c_uint;
}
extern "C" {
pub fn GuiLoadIcons(
fileName: *const ::std::os::raw::c_char,
loadIconsName: bool,
) -> *mut *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn GuiDrawIcon(
iconId: ::std::os::raw::c_int,
posX: ::std::os::raw::c_int,
posY: ::std::os::raw::c_int,
pixelSize: ::std::os::raw::c_int,
color: Color,
);
}
extern "C" {
pub fn GuiWindowBox(
bounds: Rectangle,
title: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiGroupBox(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiLine(bounds: Rectangle, text: *const ::std::os::raw::c_char)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiPanel(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiTabBar(
bounds: Rectangle,
text: *mut *const ::std::os::raw::c_char,
count: ::std::os::raw::c_int,
active: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiScrollPanel(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
content: Rectangle,
scroll: *mut Vector2,
view: *mut Rectangle,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiLabel(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiButton(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiLabelButton(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiToggle(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
active: *mut bool,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiToggleGroup(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
active: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiToggleSlider(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
active: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiCheckBox(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
checked: *mut bool,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiComboBox(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
active: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiDropdownBox(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
active: *mut ::std::os::raw::c_int,
editMode: bool,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiSpinner(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
value: *mut ::std::os::raw::c_int,
minValue: ::std::os::raw::c_int,
maxValue: ::std::os::raw::c_int,
editMode: bool,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiValueBox(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
value: *mut ::std::os::raw::c_int,
minValue: ::std::os::raw::c_int,
maxValue: ::std::os::raw::c_int,
editMode: bool,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiTextBox(
bounds: Rectangle,
text: *mut ::std::os::raw::c_char,
textSize: ::std::os::raw::c_int,
editMode: bool,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiSlider(
bounds: Rectangle,
textLeft: *const ::std::os::raw::c_char,
textRight: *const ::std::os::raw::c_char,
value: *mut f32,
minValue: f32,
maxValue: f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiSliderBar(
bounds: Rectangle,
textLeft: *const ::std::os::raw::c_char,
textRight: *const ::std::os::raw::c_char,
value: *mut f32,
minValue: f32,
maxValue: f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiProgressBar(
bounds: Rectangle,
textLeft: *const ::std::os::raw::c_char,
textRight: *const ::std::os::raw::c_char,
value: *mut f32,
minValue: f32,
maxValue: f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiStatusBar(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiDummyRec(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiGrid(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
spacing: f32,
subdivs: ::std::os::raw::c_int,
mouseCell: *mut Vector2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiListView(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
scrollIndex: *mut ::std::os::raw::c_int,
active: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiListViewEx(
bounds: Rectangle,
text: *mut *const ::std::os::raw::c_char,
count: ::std::os::raw::c_int,
scrollIndex: *mut ::std::os::raw::c_int,
active: *mut ::std::os::raw::c_int,
focus: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiMessageBox(
bounds: Rectangle,
title: *const ::std::os::raw::c_char,
message: *const ::std::os::raw::c_char,
buttons: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiTextInputBox(
bounds: Rectangle,
title: *const ::std::os::raw::c_char,
message: *const ::std::os::raw::c_char,
buttons: *const ::std::os::raw::c_char,
text: *mut ::std::os::raw::c_char,
textMaxSize: ::std::os::raw::c_int,
secretViewActive: *mut bool,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiColorPicker(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
color: *mut Color,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiColorPanel(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
color: *mut Color,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiColorBarAlpha(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
alpha: *mut f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiColorBarHue(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
value: *mut f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiColorPickerHSV(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
colorHsv: *mut Vector3,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn GuiColorPanelHSV(
bounds: Rectangle,
text: *const ::std::os::raw::c_char,
colorHsv: *mut Vector3,
) -> ::std::os::raw::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GuiIconName {
ICON_NONE = 0,
ICON_FOLDER_FILE_OPEN = 1,
ICON_FILE_SAVE_CLASSIC = 2,
ICON_FOLDER_OPEN = 3,
ICON_FOLDER_SAVE = 4,
ICON_FILE_OPEN = 5,
ICON_FILE_SAVE = 6,
ICON_FILE_EXPORT = 7,
ICON_FILE_ADD = 8,
ICON_FILE_DELETE = 9,
ICON_FILETYPE_TEXT = 10,
ICON_FILETYPE_AUDIO = 11,
ICON_FILETYPE_IMAGE = 12,
ICON_FILETYPE_PLAY = 13,
ICON_FILETYPE_VIDEO = 14,
ICON_FILETYPE_INFO = 15,
ICON_FILE_COPY = 16,
ICON_FILE_CUT = 17,
ICON_FILE_PASTE = 18,
ICON_CURSOR_HAND = 19,
ICON_CURSOR_POINTER = 20,
ICON_CURSOR_CLASSIC = 21,
ICON_PENCIL = 22,
ICON_PENCIL_BIG = 23,
ICON_BRUSH_CLASSIC = 24,
ICON_BRUSH_PAINTER = 25,
ICON_WATER_DROP = 26,
ICON_COLOR_PICKER = 27,
ICON_RUBBER = 28,
ICON_COLOR_BUCKET = 29,
ICON_TEXT_T = 30,
ICON_TEXT_A = 31,
ICON_SCALE = 32,
ICON_RESIZE = 33,
ICON_FILTER_POINT = 34,
ICON_FILTER_BILINEAR = 35,
ICON_CROP = 36,
ICON_CROP_ALPHA = 37,
ICON_SQUARE_TOGGLE = 38,
ICON_SYMMETRY = 39,
ICON_SYMMETRY_HORIZONTAL = 40,
ICON_SYMMETRY_VERTICAL = 41,
ICON_LENS = 42,
ICON_LENS_BIG = 43,
ICON_EYE_ON = 44,
ICON_EYE_OFF = 45,
ICON_FILTER_TOP = 46,
ICON_FILTER = 47,
ICON_TARGET_POINT = 48,
ICON_TARGET_SMALL = 49,
ICON_TARGET_BIG = 50,
ICON_TARGET_MOVE = 51,
ICON_CURSOR_MOVE = 52,
ICON_CURSOR_SCALE = 53,
ICON_CURSOR_SCALE_RIGHT = 54,
ICON_CURSOR_SCALE_LEFT = 55,
ICON_UNDO = 56,
ICON_REDO = 57,
ICON_REREDO = 58,
ICON_MUTATE = 59,
ICON_ROTATE = 60,
ICON_REPEAT = 61,
ICON_SHUFFLE = 62,
ICON_EMPTYBOX = 63,
ICON_TARGET = 64,
ICON_TARGET_SMALL_FILL = 65,
ICON_TARGET_BIG_FILL = 66,
ICON_TARGET_MOVE_FILL = 67,
ICON_CURSOR_MOVE_FILL = 68,
ICON_CURSOR_SCALE_FILL = 69,
ICON_CURSOR_SCALE_RIGHT_FILL = 70,
ICON_CURSOR_SCALE_LEFT_FILL = 71,
ICON_UNDO_FILL = 72,
ICON_REDO_FILL = 73,
ICON_REREDO_FILL = 74,
ICON_MUTATE_FILL = 75,
ICON_ROTATE_FILL = 76,
ICON_REPEAT_FILL = 77,
ICON_SHUFFLE_FILL = 78,
ICON_EMPTYBOX_SMALL = 79,
ICON_BOX = 80,
ICON_BOX_TOP = 81,
ICON_BOX_TOP_RIGHT = 82,
ICON_BOX_RIGHT = 83,
ICON_BOX_BOTTOM_RIGHT = 84,
ICON_BOX_BOTTOM = 85,
ICON_BOX_BOTTOM_LEFT = 86,
ICON_BOX_LEFT = 87,
ICON_BOX_TOP_LEFT = 88,
ICON_BOX_CENTER = 89,
ICON_BOX_CIRCLE_MASK = 90,
ICON_POT = 91,
ICON_ALPHA_MULTIPLY = 92,
ICON_ALPHA_CLEAR = 93,
ICON_DITHERING = 94,
ICON_MIPMAPS = 95,
ICON_BOX_GRID = 96,
ICON_GRID = 97,
ICON_BOX_CORNERS_SMALL = 98,
ICON_BOX_CORNERS_BIG = 99,
ICON_FOUR_BOXES = 100,
ICON_GRID_FILL = 101,
ICON_BOX_MULTISIZE = 102,
ICON_ZOOM_SMALL = 103,
ICON_ZOOM_MEDIUM = 104,
ICON_ZOOM_BIG = 105,
ICON_ZOOM_ALL = 106,
ICON_ZOOM_CENTER = 107,
ICON_BOX_DOTS_SMALL = 108,
ICON_BOX_DOTS_BIG = 109,
ICON_BOX_CONCENTRIC = 110,
ICON_BOX_GRID_BIG = 111,
ICON_OK_TICK = 112,
ICON_CROSS = 113,
ICON_ARROW_LEFT = 114,
ICON_ARROW_RIGHT = 115,
ICON_ARROW_DOWN = 116,
ICON_ARROW_UP = 117,
ICON_ARROW_LEFT_FILL = 118,
ICON_ARROW_RIGHT_FILL = 119,
ICON_ARROW_DOWN_FILL = 120,
ICON_ARROW_UP_FILL = 121,
ICON_AUDIO = 122,
ICON_FX = 123,
ICON_WAVE = 124,
ICON_WAVE_SINUS = 125,
ICON_WAVE_SQUARE = 126,
ICON_WAVE_TRIANGULAR = 127,
ICON_CROSS_SMALL = 128,
ICON_PLAYER_PREVIOUS = 129,
ICON_PLAYER_PLAY_BACK = 130,
ICON_PLAYER_PLAY = 131,
ICON_PLAYER_PAUSE = 132,
ICON_PLAYER_STOP = 133,
ICON_PLAYER_NEXT = 134,
ICON_PLAYER_RECORD = 135,
ICON_MAGNET = 136,
ICON_LOCK_CLOSE = 137,
ICON_LOCK_OPEN = 138,
ICON_CLOCK = 139,
ICON_TOOLS = 140,
ICON_GEAR = 141,
ICON_GEAR_BIG = 142,
ICON_BIN = 143,
ICON_HAND_POINTER = 144,
ICON_LASER = 145,
ICON_COIN = 146,
ICON_EXPLOSION = 147,
ICON_1UP = 148,
ICON_PLAYER = 149,
ICON_PLAYER_JUMP = 150,
ICON_KEY = 151,
ICON_DEMON = 152,
ICON_TEXT_POPUP = 153,
ICON_GEAR_EX = 154,
ICON_CRACK = 155,
ICON_CRACK_POINTS = 156,
ICON_STAR = 157,
ICON_DOOR = 158,
ICON_EXIT = 159,
ICON_MODE_2D = 160,
ICON_MODE_3D = 161,
ICON_CUBE = 162,
ICON_CUBE_FACE_TOP = 163,
ICON_CUBE_FACE_LEFT = 164,
ICON_CUBE_FACE_FRONT = 165,
ICON_CUBE_FACE_BOTTOM = 166,
ICON_CUBE_FACE_RIGHT = 167,
ICON_CUBE_FACE_BACK = 168,
ICON_CAMERA = 169,
ICON_SPECIAL = 170,
ICON_LINK_NET = 171,
ICON_LINK_BOXES = 172,
ICON_LINK_MULTI = 173,
ICON_LINK = 174,
ICON_LINK_BROKE = 175,
ICON_TEXT_NOTES = 176,
ICON_NOTEBOOK = 177,
ICON_SUITCASE = 178,
ICON_SUITCASE_ZIP = 179,
ICON_MAILBOX = 180,
ICON_MONITOR = 181,
ICON_PRINTER = 182,
ICON_PHOTO_CAMERA = 183,
ICON_PHOTO_CAMERA_FLASH = 184,
ICON_HOUSE = 185,
ICON_HEART = 186,
ICON_CORNER = 187,
ICON_VERTICAL_BARS = 188,
ICON_VERTICAL_BARS_FILL = 189,
ICON_LIFE_BARS = 190,
ICON_INFO = 191,
ICON_CROSSLINE = 192,
ICON_HELP = 193,
ICON_FILETYPE_ALPHA = 194,
ICON_FILETYPE_HOME = 195,
ICON_LAYERS_VISIBLE = 196,
ICON_LAYERS = 197,
ICON_WINDOW = 198,
ICON_HIDPI = 199,
ICON_FILETYPE_BINARY = 200,
ICON_HEX = 201,
ICON_SHIELD = 202,
ICON_FILE_NEW = 203,
ICON_FOLDER_ADD = 204,
ICON_ALARM = 205,
ICON_CPU = 206,
ICON_ROM = 207,
ICON_STEP_OVER = 208,
ICON_STEP_INTO = 209,
ICON_STEP_OUT = 210,
ICON_RESTART = 211,
ICON_BREAKPOINT_ON = 212,
ICON_BREAKPOINT_OFF = 213,
ICON_BURGER_MENU = 214,
ICON_CASE_SENSITIVE = 215,
ICON_REG_EXP = 216,
ICON_FOLDER = 217,
ICON_FILE = 218,
ICON_SAND_TIMER = 219,
ICON_220 = 220,
ICON_221 = 221,
ICON_222 = 222,
ICON_223 = 223,
ICON_224 = 224,
ICON_225 = 225,
ICON_226 = 226,
ICON_227 = 227,
ICON_228 = 228,
ICON_229 = 229,
ICON_230 = 230,
ICON_231 = 231,
ICON_232 = 232,
ICON_233 = 233,
ICON_234 = 234,
ICON_235 = 235,
ICON_236 = 236,
ICON_237 = 237,
ICON_238 = 238,
ICON_239 = 239,
ICON_240 = 240,
ICON_241 = 241,
ICON_242 = 242,
ICON_243 = 243,
ICON_244 = 244,
ICON_245 = 245,
ICON_246 = 246,
ICON_247 = 247,
ICON_248 = 248,
ICON_249 = 249,
ICON_250 = 250,
ICON_251 = 251,
ICON_252 = 252,
ICON_253 = 253,
ICON_254 = 254,
ICON_255 = 255,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rlVertexBuffer {
pub elementCount: ::std::os::raw::c_int,
pub vertices: *mut f32,
pub texcoords: *mut f32,
pub colors: *mut ::std::os::raw::c_uchar,
pub indices: *mut ::std::os::raw::c_uint,
pub vaoId: ::std::os::raw::c_uint,
pub vboId: [::std::os::raw::c_uint; 4usize],
}
#[test]
fn bindgen_test_layout_rlVertexBuffer() {
const UNINIT: ::std::mem::MaybeUninit<rlVertexBuffer> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rlVertexBuffer>(),
64usize,
concat!("Size of: ", stringify!(rlVertexBuffer))
);
assert_eq!(
::std::mem::align_of::<rlVertexBuffer>(),
8usize,
concat!("Alignment of ", stringify!(rlVertexBuffer))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).elementCount) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rlVertexBuffer),
"::",
stringify!(elementCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vertices) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rlVertexBuffer),
"::",
stringify!(vertices)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).texcoords) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rlVertexBuffer),
"::",
stringify!(texcoords)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).colors) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rlVertexBuffer),
"::",
stringify!(colors)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).indices) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(rlVertexBuffer),
"::",
stringify!(indices)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vaoId) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(rlVertexBuffer),
"::",
stringify!(vaoId)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vboId) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(rlVertexBuffer),
"::",
stringify!(vboId)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rlDrawCall {
pub mode: ::std::os::raw::c_int,
pub vertexCount: ::std::os::raw::c_int,
pub vertexAlignment: ::std::os::raw::c_int,
pub textureId: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_rlDrawCall() {
const UNINIT: ::std::mem::MaybeUninit<rlDrawCall> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rlDrawCall>(),
16usize,
concat!("Size of: ", stringify!(rlDrawCall))
);
assert_eq!(
::std::mem::align_of::<rlDrawCall>(),
4usize,
concat!("Alignment of ", stringify!(rlDrawCall))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rlDrawCall),
"::",
stringify!(mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vertexCount) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(rlDrawCall),
"::",
stringify!(vertexCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vertexAlignment) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rlDrawCall),
"::",
stringify!(vertexAlignment)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).textureId) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(rlDrawCall),
"::",
stringify!(textureId)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rlRenderBatch {
pub bufferCount: ::std::os::raw::c_int,
pub currentBuffer: ::std::os::raw::c_int,
pub vertexBuffer: *mut rlVertexBuffer,
pub draws: *mut rlDrawCall,
pub drawCounter: ::std::os::raw::c_int,
pub currentDepth: f32,
}
#[test]
fn bindgen_test_layout_rlRenderBatch() {
const UNINIT: ::std::mem::MaybeUninit<rlRenderBatch> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rlRenderBatch>(),
32usize,
concat!("Size of: ", stringify!(rlRenderBatch))
);
assert_eq!(
::std::mem::align_of::<rlRenderBatch>(),
8usize,
concat!("Alignment of ", stringify!(rlRenderBatch))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bufferCount) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rlRenderBatch),
"::",
stringify!(bufferCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).currentBuffer) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(rlRenderBatch),
"::",
stringify!(currentBuffer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vertexBuffer) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rlRenderBatch),
"::",
stringify!(vertexBuffer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).draws) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rlRenderBatch),
"::",
stringify!(draws)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drawCounter) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rlRenderBatch),
"::",
stringify!(drawCounter)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).currentDepth) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(rlRenderBatch),
"::",
stringify!(currentDepth)
)
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rlGlVersion {
RL_OPENGL_11 = 1,
RL_OPENGL_21 = 2,
RL_OPENGL_33 = 3,
RL_OPENGL_43 = 4,
RL_OPENGL_ES_20 = 5,
RL_OPENGL_ES_30 = 6,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rlTraceLogLevel {
RL_LOG_ALL = 0,
RL_LOG_TRACE = 1,
RL_LOG_DEBUG = 2,
RL_LOG_INFO = 3,
RL_LOG_WARNING = 4,
RL_LOG_ERROR = 5,
RL_LOG_FATAL = 6,
RL_LOG_NONE = 7,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rlPixelFormat {
RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1,
RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA = 2,
RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5 = 3,
RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8 = 4,
RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1 = 5,
RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4 = 6,
RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 = 7,
RL_PIXELFORMAT_UNCOMPRESSED_R32 = 8,
RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32 = 9,
RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 = 10,
RL_PIXELFORMAT_UNCOMPRESSED_R16 = 11,
RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16 = 12,
RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16 = 13,
RL_PIXELFORMAT_COMPRESSED_DXT1_RGB = 14,
RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA = 15,
RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA = 16,
RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA = 17,
RL_PIXELFORMAT_COMPRESSED_ETC1_RGB = 18,
RL_PIXELFORMAT_COMPRESSED_ETC2_RGB = 19,
RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA = 20,
RL_PIXELFORMAT_COMPRESSED_PVRT_RGB = 21,
RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA = 22,
RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA = 23,
RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA = 24,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rlTextureFilter {
RL_TEXTURE_FILTER_POINT = 0,
RL_TEXTURE_FILTER_BILINEAR = 1,
RL_TEXTURE_FILTER_TRILINEAR = 2,
RL_TEXTURE_FILTER_ANISOTROPIC_4X = 3,
RL_TEXTURE_FILTER_ANISOTROPIC_8X = 4,
RL_TEXTURE_FILTER_ANISOTROPIC_16X = 5,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rlBlendMode {
RL_BLEND_ALPHA = 0,
RL_BLEND_ADDITIVE = 1,
RL_BLEND_MULTIPLIED = 2,
RL_BLEND_ADD_COLORS = 3,
RL_BLEND_SUBTRACT_COLORS = 4,
RL_BLEND_ALPHA_PREMULTIPLY = 5,
RL_BLEND_CUSTOM = 6,
RL_BLEND_CUSTOM_SEPARATE = 7,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rlShaderLocationIndex {
RL_SHADER_LOC_VERTEX_POSITION = 0,
RL_SHADER_LOC_VERTEX_TEXCOORD01 = 1,
RL_SHADER_LOC_VERTEX_TEXCOORD02 = 2,
RL_SHADER_LOC_VERTEX_NORMAL = 3,
RL_SHADER_LOC_VERTEX_TANGENT = 4,
RL_SHADER_LOC_VERTEX_COLOR = 5,
RL_SHADER_LOC_MATRIX_MVP = 6,
RL_SHADER_LOC_MATRIX_VIEW = 7,
RL_SHADER_LOC_MATRIX_PROJECTION = 8,
RL_SHADER_LOC_MATRIX_MODEL = 9,
RL_SHADER_LOC_MATRIX_NORMAL = 10,
RL_SHADER_LOC_VECTOR_VIEW = 11,
RL_SHADER_LOC_COLOR_DIFFUSE = 12,
RL_SHADER_LOC_COLOR_SPECULAR = 13,
RL_SHADER_LOC_COLOR_AMBIENT = 14,
RL_SHADER_LOC_MAP_ALBEDO = 15,
RL_SHADER_LOC_MAP_METALNESS = 16,
RL_SHADER_LOC_MAP_NORMAL = 17,
RL_SHADER_LOC_MAP_ROUGHNESS = 18,
RL_SHADER_LOC_MAP_OCCLUSION = 19,
RL_SHADER_LOC_MAP_EMISSION = 20,
RL_SHADER_LOC_MAP_HEIGHT = 21,
RL_SHADER_LOC_MAP_CUBEMAP = 22,
RL_SHADER_LOC_MAP_IRRADIANCE = 23,
RL_SHADER_LOC_MAP_PREFILTER = 24,
RL_SHADER_LOC_MAP_BRDF = 25,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rlShaderUniformDataType {
RL_SHADER_UNIFORM_FLOAT = 0,
RL_SHADER_UNIFORM_VEC2 = 1,
RL_SHADER_UNIFORM_VEC3 = 2,
RL_SHADER_UNIFORM_VEC4 = 3,
RL_SHADER_UNIFORM_INT = 4,
RL_SHADER_UNIFORM_IVEC2 = 5,
RL_SHADER_UNIFORM_IVEC3 = 6,
RL_SHADER_UNIFORM_IVEC4 = 7,
RL_SHADER_UNIFORM_SAMPLER2D = 8,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rlShaderAttributeDataType {
RL_SHADER_ATTRIB_FLOAT = 0,
RL_SHADER_ATTRIB_VEC2 = 1,
RL_SHADER_ATTRIB_VEC3 = 2,
RL_SHADER_ATTRIB_VEC4 = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rlFramebufferAttachType {
RL_ATTACHMENT_COLOR_CHANNEL0 = 0,
RL_ATTACHMENT_COLOR_CHANNEL1 = 1,
RL_ATTACHMENT_COLOR_CHANNEL2 = 2,
RL_ATTACHMENT_COLOR_CHANNEL3 = 3,
RL_ATTACHMENT_COLOR_CHANNEL4 = 4,
RL_ATTACHMENT_COLOR_CHANNEL5 = 5,
RL_ATTACHMENT_COLOR_CHANNEL6 = 6,
RL_ATTACHMENT_COLOR_CHANNEL7 = 7,
RL_ATTACHMENT_DEPTH = 100,
RL_ATTACHMENT_STENCIL = 200,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rlFramebufferAttachTextureType {
RL_ATTACHMENT_CUBEMAP_POSITIVE_X = 0,
RL_ATTACHMENT_CUBEMAP_NEGATIVE_X = 1,
RL_ATTACHMENT_CUBEMAP_POSITIVE_Y = 2,
RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y = 3,
RL_ATTACHMENT_CUBEMAP_POSITIVE_Z = 4,
RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z = 5,
RL_ATTACHMENT_TEXTURE2D = 100,
RL_ATTACHMENT_RENDERBUFFER = 200,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rlCullMode {
RL_CULL_FACE_FRONT = 0,
RL_CULL_FACE_BACK = 1,
}
extern "C" {
pub fn rlMatrixMode(mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn rlPushMatrix();
}
extern "C" {
pub fn rlPopMatrix();
}
extern "C" {
pub fn rlLoadIdentity();
}
extern "C" {
pub fn rlTranslatef(x: f32, y: f32, z: f32);
}
extern "C" {
pub fn rlRotatef(angle: f32, x: f32, y: f32, z: f32);
}
extern "C" {
pub fn rlScalef(x: f32, y: f32, z: f32);
}
extern "C" {
pub fn rlMultMatrixf(matf: *const f32);
}
extern "C" {
pub fn rlFrustum(left: f64, right: f64, bottom: f64, top: f64, znear: f64, zfar: f64);
}
extern "C" {
pub fn rlOrtho(left: f64, right: f64, bottom: f64, top: f64, znear: f64, zfar: f64);
}
extern "C" {
pub fn rlViewport(
x: ::std::os::raw::c_int,
y: ::std::os::raw::c_int,
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn rlBegin(mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn rlEnd();
}
extern "C" {
pub fn rlVertex2i(x: ::std::os::raw::c_int, y: ::std::os::raw::c_int);
}
extern "C" {
pub fn rlVertex2f(x: f32, y: f32);
}
extern "C" {
pub fn rlVertex3f(x: f32, y: f32, z: f32);
}
extern "C" {
pub fn rlTexCoord2f(x: f32, y: f32);
}
extern "C" {
pub fn rlNormal3f(x: f32, y: f32, z: f32);
}
extern "C" {
pub fn rlColor4ub(
r: ::std::os::raw::c_uchar,
g: ::std::os::raw::c_uchar,
b: ::std::os::raw::c_uchar,
a: ::std::os::raw::c_uchar,
);
}
extern "C" {
pub fn rlColor3f(x: f32, y: f32, z: f32);
}
extern "C" {
pub fn rlColor4f(x: f32, y: f32, z: f32, w: f32);
}
extern "C" {
pub fn rlEnableVertexArray(vaoId: ::std::os::raw::c_uint) -> bool;
}
extern "C" {
pub fn rlDisableVertexArray();
}
extern "C" {
pub fn rlEnableVertexBuffer(id: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlDisableVertexBuffer();
}
extern "C" {
pub fn rlEnableVertexBufferElement(id: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlDisableVertexBufferElement();
}
extern "C" {
pub fn rlEnableVertexAttribute(index: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlDisableVertexAttribute(index: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlActiveTextureSlot(slot: ::std::os::raw::c_int);
}
extern "C" {
pub fn rlEnableTexture(id: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlDisableTexture();
}
extern "C" {
pub fn rlEnableTextureCubemap(id: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlDisableTextureCubemap();
}
extern "C" {
pub fn rlTextureParameters(
id: ::std::os::raw::c_uint,
param: ::std::os::raw::c_int,
value: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn rlCubemapParameters(
id: ::std::os::raw::c_uint,
param: ::std::os::raw::c_int,
value: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn rlEnableShader(id: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlDisableShader();
}
extern "C" {
pub fn rlEnableFramebuffer(id: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlDisableFramebuffer();
}
extern "C" {
pub fn rlActiveDrawBuffers(count: ::std::os::raw::c_int);
}
extern "C" {
pub fn rlBlitFramebuffer(
srcX: ::std::os::raw::c_int,
srcY: ::std::os::raw::c_int,
srcWidth: ::std::os::raw::c_int,
srcHeight: ::std::os::raw::c_int,
dstX: ::std::os::raw::c_int,
dstY: ::std::os::raw::c_int,
dstWidth: ::std::os::raw::c_int,
dstHeight: ::std::os::raw::c_int,
bufferMask: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn rlEnableColorBlend();
}
extern "C" {
pub fn rlDisableColorBlend();
}
extern "C" {
pub fn rlEnableDepthTest();
}
extern "C" {
pub fn rlDisableDepthTest();
}
extern "C" {
pub fn rlEnableDepthMask();
}
extern "C" {
pub fn rlDisableDepthMask();
}
extern "C" {
pub fn rlEnableBackfaceCulling();
}
extern "C" {
pub fn rlDisableBackfaceCulling();
}
extern "C" {
pub fn rlSetCullFace(mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn rlEnableScissorTest();
}
extern "C" {
pub fn rlDisableScissorTest();
}
extern "C" {
pub fn rlScissor(
x: ::std::os::raw::c_int,
y: ::std::os::raw::c_int,
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn rlEnableWireMode();
}
extern "C" {
pub fn rlEnablePointMode();
}
extern "C" {
pub fn rlDisableWireMode();
}
extern "C" {
pub fn rlSetLineWidth(width: f32);
}
extern "C" {
pub fn rlGetLineWidth() -> f32;
}
extern "C" {
pub fn rlEnableSmoothLines();
}
extern "C" {
pub fn rlDisableSmoothLines();
}
extern "C" {
pub fn rlEnableStereoRender();
}
extern "C" {
pub fn rlDisableStereoRender();
}
extern "C" {
pub fn rlIsStereoRenderEnabled() -> bool;
}
extern "C" {
pub fn rlClearColor(
r: ::std::os::raw::c_uchar,
g: ::std::os::raw::c_uchar,
b: ::std::os::raw::c_uchar,
a: ::std::os::raw::c_uchar,
);
}
extern "C" {
pub fn rlClearScreenBuffers();
}
extern "C" {
pub fn rlCheckErrors();
}
extern "C" {
pub fn rlSetBlendMode(mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn rlSetBlendFactors(
glSrcFactor: ::std::os::raw::c_int,
glDstFactor: ::std::os::raw::c_int,
glEquation: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn rlSetBlendFactorsSeparate(
glSrcRGB: ::std::os::raw::c_int,
glDstRGB: ::std::os::raw::c_int,
glSrcAlpha: ::std::os::raw::c_int,
glDstAlpha: ::std::os::raw::c_int,
glEqRGB: ::std::os::raw::c_int,
glEqAlpha: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn rlglInit(width: ::std::os::raw::c_int, height: ::std::os::raw::c_int);
}
extern "C" {
pub fn rlglClose();
}
extern "C" {
pub fn rlLoadExtensions(loader: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn rlGetVersion() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rlSetFramebufferWidth(width: ::std::os::raw::c_int);
}
extern "C" {
pub fn rlGetFramebufferWidth() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rlSetFramebufferHeight(height: ::std::os::raw::c_int);
}
extern "C" {
pub fn rlGetFramebufferHeight() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rlGetTextureIdDefault() -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rlGetShaderIdDefault() -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rlGetShaderLocsDefault() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn rlLoadRenderBatch(
numBuffers: ::std::os::raw::c_int,
bufferElements: ::std::os::raw::c_int,
) -> rlRenderBatch;
}
extern "C" {
pub fn rlUnloadRenderBatch(batch: rlRenderBatch);
}
extern "C" {
pub fn rlDrawRenderBatch(batch: *mut rlRenderBatch);
}
extern "C" {
pub fn rlSetRenderBatchActive(batch: *mut rlRenderBatch);
}
extern "C" {
pub fn rlDrawRenderBatchActive();
}
extern "C" {
pub fn rlCheckRenderBatchLimit(vCount: ::std::os::raw::c_int) -> bool;
}
extern "C" {
pub fn rlSetTexture(id: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlLoadVertexArray() -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rlLoadVertexBuffer(
buffer: *const ::std::os::raw::c_void,
size: ::std::os::raw::c_int,
dynamic: bool,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rlLoadVertexBufferElement(
buffer: *const ::std::os::raw::c_void,
size: ::std::os::raw::c_int,
dynamic: bool,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rlUpdateVertexBuffer(
bufferId: ::std::os::raw::c_uint,
data: *const ::std::os::raw::c_void,
dataSize: ::std::os::raw::c_int,
offset: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn rlUpdateVertexBufferElements(
id: ::std::os::raw::c_uint,
data: *const ::std::os::raw::c_void,
dataSize: ::std::os::raw::c_int,
offset: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn rlUnloadVertexArray(vaoId: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlUnloadVertexBuffer(vboId: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlSetVertexAttribute(
index: ::std::os::raw::c_uint,
compSize: ::std::os::raw::c_int,
type_: ::std::os::raw::c_int,
normalized: bool,
stride: ::std::os::raw::c_int,
pointer: *const ::std::os::raw::c_void,
);
}
extern "C" {
pub fn rlSetVertexAttributeDivisor(
index: ::std::os::raw::c_uint,
divisor: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn rlSetVertexAttributeDefault(
locIndex: ::std::os::raw::c_int,
value: *const ::std::os::raw::c_void,
attribType: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn rlDrawVertexArray(offset: ::std::os::raw::c_int, count: ::std::os::raw::c_int);
}
extern "C" {
pub fn rlDrawVertexArrayElements(
offset: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
buffer: *const ::std::os::raw::c_void,
);
}
extern "C" {
pub fn rlDrawVertexArrayInstanced(
offset: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
instances: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn rlDrawVertexArrayElementsInstanced(
offset: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
buffer: *const ::std::os::raw::c_void,
instances: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn rlLoadTexture(
data: *const ::std::os::raw::c_void,
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
format: ::std::os::raw::c_int,
mipmapCount: ::std::os::raw::c_int,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rlLoadTextureDepth(
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
useRenderBuffer: bool,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rlLoadTextureCubemap(
data: *const ::std::os::raw::c_void,
size: ::std::os::raw::c_int,
format: ::std::os::raw::c_int,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rlUpdateTexture(
id: ::std::os::raw::c_uint,
offsetX: ::std::os::raw::c_int,
offsetY: ::std::os::raw::c_int,
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
format: ::std::os::raw::c_int,
data: *const ::std::os::raw::c_void,
);
}
extern "C" {
pub fn rlGetGlTextureFormats(
format: ::std::os::raw::c_int,
glInternalFormat: *mut ::std::os::raw::c_uint,
glFormat: *mut ::std::os::raw::c_uint,
glType: *mut ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rlGetPixelFormatName(format: ::std::os::raw::c_uint) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn rlUnloadTexture(id: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlGenTextureMipmaps(
id: ::std::os::raw::c_uint,
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
format: ::std::os::raw::c_int,
mipmaps: *mut ::std::os::raw::c_int,
);
}
extern "C" {
pub fn rlReadTexturePixels(
id: ::std::os::raw::c_uint,
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
format: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn rlReadScreenPixels(
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_uchar;
}
extern "C" {
pub fn rlLoadFramebuffer(
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rlFramebufferAttach(
fboId: ::std::os::raw::c_uint,
texId: ::std::os::raw::c_uint,
attachType: ::std::os::raw::c_int,
texType: ::std::os::raw::c_int,
mipLevel: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn rlFramebufferComplete(id: ::std::os::raw::c_uint) -> bool;
}
extern "C" {
pub fn rlUnloadFramebuffer(id: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlLoadShaderCode(
vsCode: *const ::std::os::raw::c_char,
fsCode: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rlCompileShader(
shaderCode: *const ::std::os::raw::c_char,
type_: ::std::os::raw::c_int,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rlLoadShaderProgram(
vShaderId: ::std::os::raw::c_uint,
fShaderId: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rlUnloadShaderProgram(id: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlGetLocationUniform(
shaderId: ::std::os::raw::c_uint,
uniformName: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rlGetLocationAttrib(
shaderId: ::std::os::raw::c_uint,
attribName: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rlSetUniform(
locIndex: ::std::os::raw::c_int,
value: *const ::std::os::raw::c_void,
uniformType: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn rlSetUniformMatrix(locIndex: ::std::os::raw::c_int, mat: Matrix);
}
extern "C" {
pub fn rlSetUniformSampler(locIndex: ::std::os::raw::c_int, textureId: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlSetShader(id: ::std::os::raw::c_uint, locs: *mut ::std::os::raw::c_int);
}
extern "C" {
pub fn rlLoadComputeShaderProgram(shaderId: ::std::os::raw::c_uint) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rlComputeShaderDispatch(
groupX: ::std::os::raw::c_uint,
groupY: ::std::os::raw::c_uint,
groupZ: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rlLoadShaderBuffer(
size: ::std::os::raw::c_uint,
data: *const ::std::os::raw::c_void,
usageHint: ::std::os::raw::c_int,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rlUnloadShaderBuffer(ssboId: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlUpdateShaderBuffer(
id: ::std::os::raw::c_uint,
data: *const ::std::os::raw::c_void,
dataSize: ::std::os::raw::c_uint,
offset: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rlBindShaderBuffer(id: ::std::os::raw::c_uint, index: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rlReadShaderBuffer(
id: ::std::os::raw::c_uint,
dest: *mut ::std::os::raw::c_void,
count: ::std::os::raw::c_uint,
offset: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rlCopyShaderBuffer(
destId: ::std::os::raw::c_uint,
srcId: ::std::os::raw::c_uint,
destOffset: ::std::os::raw::c_uint,
srcOffset: ::std::os::raw::c_uint,
count: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rlGetShaderBufferSize(id: ::std::os::raw::c_uint) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rlBindImageTexture(
id: ::std::os::raw::c_uint,
index: ::std::os::raw::c_uint,
format: ::std::os::raw::c_int,
readonly: bool,
);
}
extern "C" {
pub fn rlGetMatrixModelview() -> Matrix;
}
extern "C" {
pub fn rlGetMatrixProjection() -> Matrix;
}
extern "C" {
pub fn rlGetMatrixTransform() -> Matrix;
}
extern "C" {
pub fn rlGetMatrixProjectionStereo(eye: ::std::os::raw::c_int) -> Matrix;
}
extern "C" {
pub fn rlGetMatrixViewOffsetStereo(eye: ::std::os::raw::c_int) -> Matrix;
}
extern "C" {
pub fn rlSetMatrixProjection(proj: Matrix);
}
extern "C" {
pub fn rlSetMatrixModelview(view: Matrix);
}
extern "C" {
pub fn rlSetMatrixProjectionStereo(right: Matrix, left: Matrix);
}
extern "C" {
pub fn rlSetMatrixViewOffsetStereo(right: Matrix, left: Matrix);
}
extern "C" {
pub fn rlLoadDrawCube();
}
extern "C" {
pub fn rlLoadDrawQuad();
}
extern "C" {
pub fn setLogCallbackWrapper();
}
extern "C" {
pub fn custom_trace_log_callback(
logType: ::std::os::raw::c_int,
text: *const ::std::os::raw::c_char,
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum guiRAYGUI_ICONName {
RAYGUI_ICON_NONE = 0,
RAYGUI_ICON_FOLDER_FILE_OPEN = 1,
RAYGUI_ICON_FILE_SAVE_CLASSIC = 2,
RAYGUI_ICON_FOLDER_OPEN = 3,
RAYGUI_ICON_FOLDER_SAVE = 4,
RAYGUI_ICON_FILE_OPEN = 5,
RAYGUI_ICON_FILE_SAVE = 6,
RAYGUI_ICON_FILE_EXPORT = 7,
RAYGUI_ICON_FILE_ADD = 8,
RAYGUI_ICON_FILE_DELETE = 9,
RAYGUI_ICON_FILETYPE_TEXT = 10,
RAYGUI_ICON_FILETYPE_AUDIO = 11,
RAYGUI_ICON_FILETYPE_IMAGE = 12,
RAYGUI_ICON_FILETYPE_PLAY = 13,
RAYGUI_ICON_FILETYPE_VIDEO = 14,
RAYGUI_ICON_FILETYPE_INFO = 15,
RAYGUI_ICON_FILE_COPY = 16,
RAYGUI_ICON_FILE_CUT = 17,
RAYGUI_ICON_FILE_PASTE = 18,
RAYGUI_ICON_CURSOR_HAND = 19,
RAYGUI_ICON_CURSOR_POINTER = 20,
RAYGUI_ICON_CURSOR_CLASSIC = 21,
RAYGUI_ICON_PENCIL = 22,
RAYGUI_ICON_PENCIL_BIG = 23,
RAYGUI_ICON_BRUSH_CLASSIC = 24,
RAYGUI_ICON_BRUSH_PAINTER = 25,
RAYGUI_ICON_WATER_DROP = 26,
RAYGUI_ICON_COLOR_PICKER = 27,
RAYGUI_ICON_RUBBER = 28,
RAYGUI_ICON_COLOR_BUCKET = 29,
RAYGUI_ICON_TEXT_T = 30,
RAYGUI_ICON_TEXT_A = 31,
RAYGUI_ICON_SCALE = 32,
RAYGUI_ICON_RESIZE = 33,
RAYGUI_ICON_FILTER_POINT = 34,
RAYGUI_ICON_FILTER_BILINEAR = 35,
RAYGUI_ICON_CROP = 36,
RAYGUI_ICON_CROP_ALPHA = 37,
RAYGUI_ICON_SQUARE_TOGGLE = 38,
RAYGUI_ICON_SYMMETRY = 39,
RAYGUI_ICON_SYMMETRY_HORIZONTAL = 40,
RAYGUI_ICON_SYMMETRY_VERTICAL = 41,
RAYGUI_ICON_LENS = 42,
RAYGUI_ICON_LENS_BIG = 43,
RAYGUI_ICON_EYE_ON = 44,
RAYGUI_ICON_EYE_OFF = 45,
RAYGUI_ICON_FILTER_TOP = 46,
RAYGUI_ICON_FILTER = 47,
RAYGUI_ICON_TARGET_POINT = 48,
RAYGUI_ICON_TARGET_SMALL = 49,
RAYGUI_ICON_TARGET_BIG = 50,
RAYGUI_ICON_TARGET_MOVE = 51,
RAYGUI_ICON_CURSOR_MOVE = 52,
RAYGUI_ICON_CURSOR_SCALE = 53,
RAYGUI_ICON_CURSOR_SCALE_RIGHT = 54,
RAYGUI_ICON_CURSOR_SCALE_LEFT = 55,
RAYGUI_ICON_UNDO = 56,
RAYGUI_ICON_REDO = 57,
RAYGUI_ICON_REREDO = 58,
RAYGUI_ICON_MUTATE = 59,
RAYGUI_ICON_ROTATE = 60,
RAYGUI_ICON_REPEAT = 61,
RAYGUI_ICON_SHUFFLE = 62,
RAYGUI_ICON_EMPTYBOX = 63,
RAYGUI_ICON_TARGET = 64,
RAYGUI_ICON_TARGET_SMALL_FILL = 65,
RAYGUI_ICON_TARGET_BIG_FILL = 66,
RAYGUI_ICON_TARGET_MOVE_FILL = 67,
RAYGUI_ICON_CURSOR_MOVE_FILL = 68,
RAYGUI_ICON_CURSOR_SCALE_FILL = 69,
RAYGUI_ICON_CURSOR_SCALE_RIGHT_FILL = 70,
RAYGUI_ICON_CURSOR_SCALE_LEFT_FILL = 71,
RAYGUI_ICON_UNDO_FILL = 72,
RAYGUI_ICON_REDO_FILL = 73,
RAYGUI_ICON_REREDO_FILL = 74,
RAYGUI_ICON_MUTATE_FILL = 75,
RAYGUI_ICON_ROTATE_FILL = 76,
RAYGUI_ICON_REPEAT_FILL = 77,
RAYGUI_ICON_SHUFFLE_FILL = 78,
RAYGUI_ICON_EMPTYBOX_SMALL = 79,
RAYGUI_ICON_BOX = 80,
RAYGUI_ICON_BOX_TOP = 81,
RAYGUI_ICON_BOX_TOP_RIGHT = 82,
RAYGUI_ICON_BOX_RIGHT = 83,
RAYGUI_ICON_BOX_BOTTOM_RIGHT = 84,
RAYGUI_ICON_BOX_BOTTOM = 85,
RAYGUI_ICON_BOX_BOTTOM_LEFT = 86,
RAYGUI_ICON_BOX_LEFT = 87,
RAYGUI_ICON_BOX_TOP_LEFT = 88,
RAYGUI_ICON_BOX_CENTER = 89,
RAYGUI_ICON_BOX_CIRCLE_MASK = 90,
RAYGUI_ICON_POT = 91,
RAYGUI_ICON_ALPHA_MULTIPLY = 92,
RAYGUI_ICON_ALPHA_CLEAR = 93,
RAYGUI_ICON_DITHERING = 94,
RAYGUI_ICON_MIPMAPS = 95,
RAYGUI_ICON_BOX_GRID = 96,
RAYGUI_ICON_GRID = 97,
RAYGUI_ICON_BOX_CORNERS_SMALL = 98,
RAYGUI_ICON_BOX_CORNERS_BIG = 99,
RAYGUI_ICON_FOUR_BOXES = 100,
RAYGUI_ICON_GRID_FILL = 101,
RAYGUI_ICON_BOX_MULTISIZE = 102,
RAYGUI_ICON_ZOOM_SMALL = 103,
RAYGUI_ICON_ZOOM_MEDIUM = 104,
RAYGUI_ICON_ZOOM_BIG = 105,
RAYGUI_ICON_ZOOM_ALL = 106,
RAYGUI_ICON_ZOOM_CENTER = 107,
RAYGUI_ICON_BOX_DOTS_SMALL = 108,
RAYGUI_ICON_BOX_DOTS_BIG = 109,
RAYGUI_ICON_BOX_CONCENTRIC = 110,
RAYGUI_ICON_BOX_GRID_BIG = 111,
RAYGUI_ICON_OK_TICK = 112,
RAYGUI_ICON_CROSS = 113,
RAYGUI_ICON_ARROW_LEFT = 114,
RAYGUI_ICON_ARROW_RIGHT = 115,
RAYGUI_ICON_ARROW_DOWN = 116,
RAYGUI_ICON_ARROW_UP = 117,
RAYGUI_ICON_ARROW_LEFT_FILL = 118,
RAYGUI_ICON_ARROW_RIGHT_FILL = 119,
RAYGUI_ICON_ARROW_DOWN_FILL = 120,
RAYGUI_ICON_ARROW_UP_FILL = 121,
RAYGUI_ICON_AUDIO = 122,
RAYGUI_ICON_FX = 123,
RAYGUI_ICON_WAVE = 124,
RAYGUI_ICON_WAVE_SINUS = 125,
RAYGUI_ICON_WAVE_SQUARE = 126,
RAYGUI_ICON_WAVE_TRIANGULAR = 127,
RAYGUI_ICON_CROSS_SMALL = 128,
RAYGUI_ICON_PLAYER_PREVIOUS = 129,
RAYGUI_ICON_PLAYER_PLAY_BACK = 130,
RAYGUI_ICON_PLAYER_PLAY = 131,
RAYGUI_ICON_PLAYER_PAUSE = 132,
RAYGUI_ICON_PLAYER_STOP = 133,
RAYGUI_ICON_PLAYER_NEXT = 134,
RAYGUI_ICON_PLAYER_RECORD = 135,
RAYGUI_ICON_MAGNET = 136,
RAYGUI_ICON_LOCK_CLOSE = 137,
RAYGUI_ICON_LOCK_OPEN = 138,
RAYGUI_ICON_CLOCK = 139,
RAYGUI_ICON_TOOLS = 140,
RAYGUI_ICON_GEAR = 141,
RAYGUI_ICON_GEAR_BIG = 142,
RAYGUI_ICON_BIN = 143,
RAYGUI_ICON_HAND_POINTER = 144,
RAYGUI_ICON_LASER = 145,
RAYGUI_ICON_COIN = 146,
RAYGUI_ICON_EXPLOSION = 147,
RAYGUI_ICON_1UP = 148,
RAYGUI_ICON_PLAYER = 149,
RAYGUI_ICON_PLAYER_JUMP = 150,
RAYGUI_ICON_KEY = 151,
RAYGUI_ICON_DEMON = 152,
RAYGUI_ICON_TEXT_POPUP = 153,
RAYGUI_ICON_GEAR_EX = 154,
RAYGUI_ICON_CRACK = 155,
RAYGUI_ICON_CRACK_POINTS = 156,
RAYGUI_ICON_STAR = 157,
RAYGUI_ICON_DOOR = 158,
RAYGUI_ICON_EXIT = 159,
RAYGUI_ICON_MODE_2D = 160,
RAYGUI_ICON_MODE_3D = 161,
RAYGUI_ICON_CUBE = 162,
RAYGUI_ICON_CUBE_FACE_TOP = 163,
RAYGUI_ICON_CUBE_FACE_LEFT = 164,
RAYGUI_ICON_CUBE_FACE_FRONT = 165,
RAYGUI_ICON_CUBE_FACE_BOTTOM = 166,
RAYGUI_ICON_CUBE_FACE_RIGHT = 167,
RAYGUI_ICON_CUBE_FACE_BACK = 168,
RAYGUI_ICON_CAMERA = 169,
RAYGUI_ICON_SPECIAL = 170,
RAYGUI_ICON_LINK_NET = 171,
RAYGUI_ICON_LINK_BOXES = 172,
RAYGUI_ICON_LINK_MULTI = 173,
RAYGUI_ICON_LINK = 174,
RAYGUI_ICON_LINK_BROKE = 175,
RAYGUI_ICON_TEXT_NOTES = 176,
RAYGUI_ICON_NOTEBOOK = 177,
RAYGUI_ICON_SUITCASE = 178,
RAYGUI_ICON_SUITCASE_ZIP = 179,
RAYGUI_ICON_MAILBOX = 180,
RAYGUI_ICON_MONITOR = 181,
RAYGUI_ICON_PRINTER = 182,
RAYGUI_ICON_PHOTO_CAMERA = 183,
RAYGUI_ICON_PHOTO_CAMERA_FLASH = 184,
RAYGUI_ICON_HOUSE = 185,
RAYGUI_ICON_HEART = 186,
RAYGUI_ICON_CORNER = 187,
RAYGUI_ICON_VERTICAL_BARS = 188,
RAYGUI_ICON_VERTICAL_BARS_FILL = 189,
RAYGUI_ICON_LIFE_BARS = 190,
RAYGUI_ICON_INFO = 191,
RAYGUI_ICON_CROSSLINE = 192,
RAYGUI_ICON_HELP = 193,
RAYGUI_ICON_FILETYPE_ALPHA = 194,
RAYGUI_ICON_FILETYPE_HOME = 195,
RAYGUI_ICON_LAYERS_VISIBLE = 196,
RAYGUI_ICON_LAYERS = 197,
RAYGUI_ICON_WINDOW = 198,
RAYGUI_ICON_HIDPI = 199,
RAYGUI_ICON_FILETYPE_BINARY = 200,
RAYGUI_ICON_HEX = 201,
RAYGUI_ICON_SHIELD = 202,
RAYGUI_ICON_FILE_NEW = 203,
RAYGUI_ICON_FOLDER_ADD = 204,
RAYGUI_ICON_ALARM = 205,
RAYGUI_ICON_CPU = 206,
RAYGUI_ICON_ROM = 207,
RAYGUI_ICON_STEP_OVER = 208,
RAYGUI_ICON_STEP_INTO = 209,
RAYGUI_ICON_STEP_OUT = 210,
RAYGUI_ICON_RESTART = 211,
RAYGUI_ICON_BREAKPOINT_ON = 212,
RAYGUI_ICON_BREAKPOINT_OFF = 213,
RAYGUI_ICON_BURGER_MENU = 214,
RAYGUI_ICON_CASE_SENSITIVE = 215,
RAYGUI_ICON_REG_EXP = 216,
RAYGUI_ICON_FOLDER = 217,
RAYGUI_ICON_FILE = 218,
RAYGUI_ICON_219 = 219,
RAYGUI_ICON_220 = 220,
RAYGUI_ICON_221 = 221,
RAYGUI_ICON_222 = 222,
RAYGUI_ICON_223 = 223,
RAYGUI_ICON_224 = 224,
RAYGUI_ICON_225 = 225,
RAYGUI_ICON_226 = 226,
RAYGUI_ICON_227 = 227,
RAYGUI_ICON_228 = 228,
RAYGUI_ICON_229 = 229,
RAYGUI_ICON_230 = 230,
RAYGUI_ICON_231 = 231,
RAYGUI_ICON_232 = 232,
RAYGUI_ICON_233 = 233,
RAYGUI_ICON_234 = 234,
RAYGUI_ICON_235 = 235,
RAYGUI_ICON_236 = 236,
RAYGUI_ICON_237 = 237,
RAYGUI_ICON_238 = 238,
RAYGUI_ICON_239 = 239,
RAYGUI_ICON_240 = 240,
RAYGUI_ICON_241 = 241,
RAYGUI_ICON_242 = 242,
RAYGUI_ICON_243 = 243,
RAYGUI_ICON_244 = 244,
RAYGUI_ICON_245 = 245,
RAYGUI_ICON_246 = 246,
RAYGUI_ICON_247 = 247,
RAYGUI_ICON_248 = 248,
RAYGUI_ICON_249 = 249,
RAYGUI_ICON_250 = 250,
RAYGUI_ICON_251 = 251,
RAYGUI_ICON_252 = 252,
RAYGUI_ICON_253 = 253,
RAYGUI_ICON_254 = 254,
RAYGUI_ICON_255 = 255,
}
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() {
const UNINIT: ::std::mem::MaybeUninit<__va_list_tag> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).gp_offset) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(gp_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fp_offset) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(fp_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).overflow_arg_area) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(overflow_arg_area)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reg_save_area) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(reg_save_area)
)
);
}