encounter/rust-sdl2
0
0
Fork 0
mirror of https://github.com/encounter/rust-sdl2.git synced 2026-07-10 21:18:41 -07:00
Code Issues Packages Projects Releases Wiki Activity

Move SDL_image to sdl2-sys crate

Browse Source 
Progresses on #647
This commit is contained in:
Jon Emil Jahren
2018-04-02 11:18:54 +02:00
parent 0fb0dc54f3
commit d2a7233827
6 changed files with 67 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.toml
+1 -1
View File
@@ -38,9 +38,9 @@ optional = true
unsafe_textures = []
default = []
ttf = []
image = []
gfx = ["c_vec"]
mixer = ["sdl2-sys/mixer"]
image = ["sdl2-sys/image"]
use-bindgen = ["sdl2-sys/use-bindgen"]
use-pkgconfig = ["sdl2-sys/use-pkgconfig"]
sdl2-sys/Cargo.toml
+1
View File
@@ -51,3 +51,4 @@ static-link = []
use_mac_framework = []
bundled = ["cmake", "reqwest", "tar", "flate2"]
mixer = []
image = []
sdl2-sys/build.rs
+17 -6
View File
@@ -204,12 +204,23 @@ fn link_sdl2(target_os: &str) {
// leaves it up to the user to make a symlink to the shared object so
// -lSDL2_mixer can find it.
#[cfg(all(not(feature = "use-pkgconfig"), not(feature = "static-link")))] {
if cfg!(all(any(target_os="linux", target_os="freebsd"), feature = "mixer")) {
println!("cargo:rustc-flags=-l SDL2_mixer");
} else if cfg!(all(target_os="windows", feature = "mixer")) {
println!("cargo:rustc-flags=-l SDL2_mixer");
} else if cfg!(all(any(target_os="macos", feature="use_mac_framework"), feature = "mixer")) {
println!("cargo:rustc-flags=-l framework=SDL2_mixer");
if cfg!(feature = "mixer") {
if cfg!(any(target_os="linux", target_os="freebsd")) {
println!("cargo:rustc-flags=-l SDL2_mixer");
} else if cfg!(target_os="windows") {
println!("cargo:rustc-flags=-l SDL2_mixer");
} else if cfg!(any(target_os="macos", feature="use_mac_framework")) {
println!("cargo:rustc-flags=-l framework=SDL2_mixer");
}
}
if cfg!(feature = "image") {
if cfg!(any(target_os="linux", target_os="freebsd")) {
println!("cargo:rustc-flags=-l SDL2_image");
} else if cfg!(target_os="windows") {
println!("cargo:rustc-flags=-l SDL2_image");
} else if cfg!(any(target_os="macos", feature="use_mac_framework")) {
println!("cargo:rustc-flags=-l framework=SDL2_image");
}
}
}
}
src/sdl2/image/ffi.rs → sdl2-sys/src/image.rs
+2 -3
View File
@@ -1,6 +1,5 @@
use std::os::raw::{c_int, c_char};
use sys;
use sys::{SDL_RWops, SDL_Surface, SDL_Renderer, SDL_Texture};
use ::{SDL_RWops, SDL_Surface, SDL_Renderer, SDL_Texture};
pub type IMG_InitFlags = c_int;
pub const IMG_INIT_JPG: IMG_InitFlags = 0x00_00_00_01;
@@ -11,7 +10,7 @@ pub const IMG_INIT_WEBP: IMG_InitFlags = 0x00_00_00_08;
extern "C" {
// This function gets the version of the dynamically linked SDL_image library.
pub fn IMG_Linked_Version() -> *const sys::SDL_version;
pub fn IMG_Linked_Version() -> *const ::SDL_version;
// Loads dynamic libraries and prepares them for use. Flags should be
// one or more flags from IMG_InitFlags OR'd together.
sdl2-sys/src/lib.rs
+3
View File
@@ -12,3 +12,6 @@ include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
#[cfg(feature = "mixer")]
pub mod mixer;
#[cfg(feature = "image")]
pub mod image;
src/sdl2/image/mod.rs
Executable → Regular
+43 -64
View File
@@ -30,35 +30,14 @@ use version::Version;
use get_error;
use sys;
// Setup linking for all targets.
#[cfg(target_os="macos")]
mod mac {
#[cfg(any(mac_framework, feature="use_mac_framework"))]
#[link(kind="framework", name="SDL2_image")]
extern "C" {}
#[cfg(not(any(mac_framework, feature="use_mac_framework")))]
#[link(name="SDL2_image")]
extern "C" {}
}
#[cfg(any(target_os="windows", target_os="linux", target_os="freebsd"))]
mod others {
#[link(name="SDL2_image")]
extern "C" {}
}
#[allow(non_camel_case_types, dead_code)]
mod ffi;
/// InitFlags are passed to init() to control which subsystem
/// functionality to load.
bitflags! {
pub flags InitFlag : u32 {
const INIT_JPG = ffi::IMG_INIT_JPG as u32,
const INIT_PNG = ffi::IMG_INIT_PNG as u32,
const INIT_TIF = ffi::IMG_INIT_TIF as u32,
const INIT_WEBP = ffi::IMG_INIT_WEBP as u32
const INIT_JPG = sys::image::IMG_INIT_JPG as u32,
const INIT_PNG = sys::image::IMG_INIT_PNG as u32,
const INIT_TIF = sys::image::IMG_INIT_TIF as u32,
const INIT_WEBP = sys::image::IMG_INIT_WEBP as u32
}
}
@@ -102,7 +81,7 @@ impl<'a> LoadSurface for Surface<'a> {
//! Loads an SDL Surface from a file
unsafe {
let c_filename = CString::new(filename.as_ref().to_str().unwrap()).unwrap();
let raw = ffi::IMG_Load(c_filename.as_ptr() as *const _);
let raw = sys::image::IMG_Load(c_filename.as_ptr() as *const _);
if (raw as *mut ()).is_null() {
Err(get_error())
} else {
@@ -114,7 +93,7 @@ impl<'a> LoadSurface for Surface<'a> {
fn from_xpm_array(xpm: *const *const i8) -> Result<Surface<'a>, String> {
//! Loads an SDL Surface from XPM data
unsafe {
let raw = ffi::IMG_ReadXPMFromArray(xpm as *const *const c_char);
let raw = sys::image::IMG_ReadXPMFromArray(xpm as *const *const c_char);
if (raw as *mut ()).is_null() {
Err(get_error())
} else {
@@ -129,7 +108,7 @@ impl<'a> SaveSurface for Surface<'a> {
//! Saves an SDL Surface to a file
unsafe {
let c_filename = CString::new(filename.as_ref().to_str().unwrap()).unwrap();
let status = ffi::IMG_SavePNG(self.raw(), c_filename.as_ptr() as *const _);
let status = sys::image::IMG_SavePNG(self.raw(), c_filename.as_ptr() as *const _);
if status != 0 {
Err(get_error())
} else {
@@ -141,7 +120,7 @@ impl<'a> SaveSurface for Surface<'a> {
fn save_rw(&self, dst: &mut RWops) -> Result<(), String> {
//! Saves an SDL Surface to an RWops
unsafe {
let status = ffi::IMG_SavePNG_RW(self.raw(), dst.raw(), 0);
let status = sys::image::IMG_SavePNG_RW(self.raw(), dst.raw(), 0);
if status != 0 {
Err(get_error())
@@ -162,7 +141,7 @@ impl<T> LoadTexture for TextureCreator<T> {
//! Loads an SDL Texture from a file
unsafe {
let c_filename = CString::new(filename.as_ref().to_str().unwrap()).unwrap();
let raw = ffi::IMG_LoadTexture(self.raw(), c_filename.as_ptr() as *const _);
let raw = sys::image::IMG_LoadTexture(self.raw(), c_filename.as_ptr() as *const _);
if (raw as *mut ()).is_null() {
Err(get_error())
} else {
@@ -179,7 +158,7 @@ pub struct Sdl2ImageContext;
impl Drop for Sdl2ImageContext {
fn drop(&mut self) {
unsafe {
ffi::IMG_Quit();
sys::image::IMG_Quit();
}
}
}
@@ -188,7 +167,7 @@ impl Drop for Sdl2ImageContext {
/// If not every flag is set it returns an error
pub fn init(flags: InitFlag) -> Result<Sdl2ImageContext, String> {
let return_flags = unsafe {
let used = ffi::IMG_Init(flags.bits() as c_int);
let used = sys::image::IMG_Init(flags.bits() as c_int);
InitFlag::from_bits_truncate(used as u32)
};
if !flags.intersects(return_flags) {
@@ -207,7 +186,7 @@ pub fn init(flags: InitFlag) -> Result<Sdl2ImageContext, String> {
/// Returns the version of the dynamically linked `SDL_image` library
pub fn get_linked_version() -> Version {
unsafe { Version::from_ll(*ffi::IMG_Linked_Version()) }
unsafe { Version::from_ll(*sys::image::IMG_Linked_Version()) }
}
#[inline]
@@ -259,118 +238,118 @@ pub trait ImageRWops {
impl<'a> ImageRWops for RWops<'a> {
fn load(&self) -> Result<Surface, String> {
let raw = unsafe { ffi::IMG_Load_RW(self.raw(), 0) };
let raw = unsafe { sys::image::IMG_Load_RW(self.raw(), 0) };
to_surface_result(raw)
}
fn load_typed(&self, _type: &str) -> Result<Surface, String> {
let raw = unsafe {
let c_type = CString::new(_type.as_bytes()).unwrap();
ffi::IMG_LoadTyped_RW(self.raw(), 0, c_type.as_ptr() as *const _)
sys::image::IMG_LoadTyped_RW(self.raw(), 0, c_type.as_ptr() as *const _)
};
to_surface_result(raw)
}
fn load_cur(&self) -> Result<Surface, String> {
let raw = unsafe { ffi::IMG_LoadCUR_RW(self.raw()) };
let raw = unsafe { sys::image::IMG_LoadCUR_RW(self.raw()) };
to_surface_result(raw)
}
fn load_ico(&self) -> Result<Surface, String> {
let raw = unsafe { ffi::IMG_LoadICO_RW(self.raw()) };
let raw = unsafe { sys::image::IMG_LoadICO_RW(self.raw()) };
to_surface_result(raw)
}
fn load_bmp(&self) -> Result<Surface, String> {
let raw = unsafe { ffi::IMG_LoadBMP_RW(self.raw()) };
let raw = unsafe { sys::image::IMG_LoadBMP_RW(self.raw()) };
to_surface_result(raw)
}
fn load_pnm(&self) -> Result<Surface, String> {
let raw = unsafe { ffi::IMG_LoadPNM_RW(self.raw()) };
let raw = unsafe { sys::image::IMG_LoadPNM_RW(self.raw()) };
to_surface_result(raw)
}
fn load_xpm(&self) -> Result<Surface, String> {
let raw = unsafe { ffi::IMG_LoadXPM_RW(self.raw()) };
let raw = unsafe { sys::image::IMG_LoadXPM_RW(self.raw()) };
to_surface_result(raw)
}
fn load_xcf(&self) -> Result<Surface, String> {
let raw = unsafe { ffi::IMG_LoadXCF_RW(self.raw()) };
let raw = unsafe { sys::image::IMG_LoadXCF_RW(self.raw()) };
to_surface_result(raw)
}
fn load_pcx(&self) -> Result<Surface, String> {
let raw = unsafe { ffi::IMG_LoadPCX_RW(self.raw()) };
let raw = unsafe { sys::image::IMG_LoadPCX_RW(self.raw()) };
to_surface_result(raw)
}
fn load_gif(&self) -> Result<Surface, String> {
let raw = unsafe { ffi::IMG_LoadGIF_RW(self.raw()) };
let raw = unsafe { sys::image::IMG_LoadGIF_RW(self.raw()) };
to_surface_result(raw)
}
fn load_jpg(&self) -> Result<Surface, String> {
let raw = unsafe { ffi::IMG_LoadJPG_RW(self.raw()) };
let raw = unsafe { sys::image::IMG_LoadJPG_RW(self.raw()) };
to_surface_result(raw)
}
fn load_tif(&self) -> Result<Surface, String> {
let raw = unsafe { ffi::IMG_LoadTIF_RW(self.raw()) };
let raw = unsafe { sys::image::IMG_LoadTIF_RW(self.raw()) };
to_surface_result(raw)
}
fn load_png(&self) -> Result<Surface, String> {
let raw = unsafe { ffi::IMG_LoadPNG_RW(self.raw()) };
let raw = unsafe { sys::image::IMG_LoadPNG_RW(self.raw()) };
to_surface_result(raw)
}
fn load_tga(&self) -> Result<Surface, String> {
let raw = unsafe { ffi::IMG_LoadTGA_RW(self.raw()) };
let raw = unsafe { sys::image::IMG_LoadTGA_RW(self.raw()) };
to_surface_result(raw)
}
fn load_lbm(&self) -> Result<Surface, String> {
let raw = unsafe { ffi::IMG_LoadLBM_RW(self.raw()) };
let raw = unsafe { sys::image::IMG_LoadLBM_RW(self.raw()) };
to_surface_result(raw)
}
fn load_xv(&self) -> Result<Surface, String> {
let raw = unsafe { ffi::IMG_LoadXV_RW(self.raw()) };
let raw = unsafe { sys::image::IMG_LoadXV_RW(self.raw()) };
to_surface_result(raw)
}
fn load_webp(&self) -> Result<Surface, String> {
let raw = unsafe { ffi::IMG_LoadWEBP_RW(self.raw()) };
let raw = unsafe { sys::image::IMG_LoadWEBP_RW(self.raw()) };
to_surface_result(raw)
}
fn is_cur(&self) -> bool {
unsafe { ffi::IMG_isCUR(self.raw()) == 1 }
unsafe { sys::image::IMG_isCUR(self.raw()) == 1 }
}
fn is_ico(&self) -> bool {
unsafe { ffi::IMG_isICO(self.raw()) == 1 }
unsafe { sys::image::IMG_isICO(self.raw()) == 1 }
}
fn is_bmp(&self) -> bool {
unsafe { ffi::IMG_isBMP(self.raw()) == 1 }
unsafe { sys::image::IMG_isBMP(self.raw()) == 1 }
}
fn is_pnm(&self) -> bool {
unsafe { ffi::IMG_isPNM(self.raw()) == 1 }
unsafe { sys::image::IMG_isPNM(self.raw()) == 1 }
}
fn is_xpm(&self) -> bool {
unsafe { ffi::IMG_isXPM(self.raw()) == 1 }
unsafe { sys::image::IMG_isXPM(self.raw()) == 1 }
}
fn is_xcf(&self) -> bool {
unsafe { ffi::IMG_isXCF(self.raw()) == 1 }
unsafe { sys::image::IMG_isXCF(self.raw()) == 1 }
}
fn is_pcx(&self) -> bool {
unsafe { ffi::IMG_isPCX(self.raw()) == 1 }
unsafe { sys::image::IMG_isPCX(self.raw()) == 1 }
}
fn is_gif(&self) -> bool {
unsafe { ffi::IMG_isGIF(self.raw()) == 1 }
unsafe { sys::image::IMG_isGIF(self.raw()) == 1 }
}
fn is_jpg(&self) -> bool {
unsafe { ffi::IMG_isJPG(self.raw()) == 1 }
unsafe { sys::image::IMG_isJPG(self.raw()) == 1 }
}
fn is_tif(&self) -> bool {
unsafe { ffi::IMG_isTIF(self.raw()) == 1 }
unsafe { sys::image::IMG_isTIF(self.raw()) == 1 }
}
fn is_png(&self) -> bool {
unsafe { ffi::IMG_isPNG(self.raw()) == 1 }
unsafe { sys::image::IMG_isPNG(self.raw()) == 1 }
}
fn is_lbm(&self) -> bool {
unsafe { ffi::IMG_isLBM(self.raw()) == 1 }
unsafe { sys::image::IMG_isLBM(self.raw()) == 1 }
}
fn is_xv(&self) -> bool {
unsafe { ffi::IMG_isXV(self.raw()) == 1 }
unsafe { sys::image::IMG_isXV(self.raw()) == 1 }
}
fn is_webp(&self) -> bool {
unsafe { ffi::IMG_isWEBP(self.raw()) == 1 }
unsafe { sys::image::IMG_isWEBP(self.raw()) == 1 }
}
}