diff options
| -rw-r--r-- | src/api/caca/libcaca.rs | 187 | ||||
| -rw-r--r-- | src/api/caca/mod.rs | 241 | ||||
| -rw-r--r-- | src/api/mod.rs | 1 | ||||
| -rw-r--r-- | src/api/osmesa/mod.rs | 8 |
4 files changed, 437 insertions, 0 deletions
diff --git a/src/api/caca/libcaca.rs b/src/api/caca/libcaca.rs new file mode 100644 index 0000000..ce2d281 --- /dev/null +++ b/src/api/caca/libcaca.rs @@ -0,0 +1,187 @@ +use libc; +use std::ffi::CStr; +use std::mem; +use api::dlopen; + +pub type caca_display_t = libc::c_void; +pub type caca_canvas_t = libc::c_void; +pub type caca_dither_t = libc::c_void; + +pub struct LibCaca { + lib: *mut libc::c_void, + + caca_create_display: unsafe extern fn(*mut caca_canvas_t) -> *mut caca_display_t, + caca_free_display: unsafe extern fn(*mut caca_display_t) -> libc::c_int, + caca_get_canvas: unsafe extern fn(*mut caca_display_t) -> *mut caca_canvas_t, + caca_refresh_display: unsafe extern fn(*mut caca_display_t) -> libc::c_int, + caca_dither_bitmap: unsafe extern fn(*mut caca_canvas_t, libc::c_int, libc::c_int, libc::c_int, + libc::c_int, *const caca_dither_t, *const libc::c_void) + -> libc::c_int, + caca_free_dither: unsafe extern fn(*mut caca_dither_t) -> libc::c_int, + caca_create_dither: unsafe extern fn(libc::c_int, libc::c_int, libc::c_int, libc::c_int, + libc::uint32_t, libc::uint32_t, libc::uint32_t, + libc::uint32_t) -> *mut caca_dither_t, + caca_get_canvas_width: unsafe extern fn(*mut caca_canvas_t) -> libc::c_int, + caca_get_canvas_height: unsafe extern fn(*mut caca_canvas_t) -> libc::c_int, +} + +#[derive(Debug)] +pub struct OpenError { + reason: String +} + +impl LibCaca { + pub fn open() -> Result<LibCaca, OpenError> { + let lib = unsafe { dlopen::dlopen(b"libcaca.so.0\0".as_ptr() as *const _, + dlopen::RTLD_NOW) }; + + if lib.is_null() { + let cstr = unsafe { CStr::from_ptr(dlopen::dlerror()) }; + let reason = String::from_utf8(cstr.to_bytes().to_vec()).unwrap(); + return Err(OpenError { reason: reason }); + } + + let caca_create_display = match unsafe { dlopen::dlsym(lib, + b"caca_create_display\0".as_ptr() as *const _) } + { + ptr if ptr.is_null() => return Err(OpenError { + reason: "Could not load caca_create_display".to_string() + }), + ptr => ptr + }; + + let caca_free_display = match unsafe { dlopen::dlsym(lib, + b"caca_free_display\0".as_ptr() as *const _) } + { + ptr if ptr.is_null() => return Err(OpenError { + reason: "Could not load caca_free_display".to_string() + }), + ptr => ptr + }; + + let caca_get_canvas = match unsafe { dlopen::dlsym(lib, + b"caca_get_canvas\0".as_ptr() as *const _) } + { + ptr if ptr.is_null() => return Err(OpenError { + reason: "Could not load caca_get_canvas".to_string() + }), + ptr => ptr + }; + + let caca_refresh_display = match unsafe { dlopen::dlsym(lib, + b"caca_refresh_display\0".as_ptr() as *const _) } + { + ptr if ptr.is_null() => return Err(OpenError { + reason: "Could not load caca_refresh_display".to_string() + }), + ptr => ptr + }; + + let caca_dither_bitmap = match unsafe { dlopen::dlsym(lib, + b"caca_dither_bitmap\0".as_ptr() as *const _) } + { + ptr if ptr.is_null() => return Err(OpenError { + reason: "Could not load caca_dither_bitmap".to_string() + }), + ptr => ptr + }; + + let caca_free_dither = match unsafe { dlopen::dlsym(lib, + b"caca_free_dither\0".as_ptr() as *const _) } + { + ptr if ptr.is_null() => return Err(OpenError { + reason: "Could not load caca_free_dither".to_string() + }), + ptr => ptr + }; + + let caca_create_dither = match unsafe { dlopen::dlsym(lib, + b"caca_create_dither\0".as_ptr() as *const _) } + { + ptr if ptr.is_null() => return Err(OpenError { + reason: "Could not load caca_create_dither".to_string() + }), + ptr => ptr + }; + + let caca_get_canvas_width = match unsafe { dlopen::dlsym(lib, + b"caca_get_canvas_width\0".as_ptr() as *const _) } + { + ptr if ptr.is_null() => return Err(OpenError { + reason: "Could not load caca_get_canvas_width".to_string() + }), + ptr => ptr + }; + + let caca_get_canvas_height = match unsafe { dlopen::dlsym(lib, + b"caca_get_canvas_height\0".as_ptr() as *const _) } + { + ptr if ptr.is_null() => return Err(OpenError { + reason: "Could not load caca_get_canvas_height".to_string() + }), + ptr => ptr + }; + + Ok(LibCaca { + lib: lib, + + caca_create_display: unsafe { mem::transmute(caca_create_display) }, + caca_free_display: unsafe { mem::transmute(caca_free_display) }, + caca_get_canvas: unsafe { mem::transmute(caca_get_canvas) }, + caca_refresh_display: unsafe { mem::transmute(caca_refresh_display) }, + caca_dither_bitmap: unsafe { mem::transmute(caca_dither_bitmap) }, + caca_free_dither: unsafe { mem::transmute(caca_free_dither) }, + caca_create_dither: unsafe { mem::transmute(caca_create_dither) }, + caca_get_canvas_width: unsafe { mem::transmute(caca_get_canvas_width) }, + caca_get_canvas_height: unsafe { mem::transmute(caca_get_canvas_height) }, + }) + } + + pub unsafe fn caca_create_display(&self, cv: *mut caca_canvas_t) -> *mut caca_display_t { + (self.caca_create_display)(cv) + } + + pub unsafe fn caca_free_display(&self, dp: *mut caca_display_t) -> libc::c_int { + (self.caca_free_display)(dp) + } + + pub unsafe fn caca_get_canvas(&self, dp: *mut caca_display_t) -> *mut caca_canvas_t { + (self.caca_get_canvas)(dp) + } + + pub unsafe fn caca_refresh_display(&self, dp: *mut caca_display_t) -> libc::c_int { + (self.caca_refresh_display)(dp) + } + + pub unsafe fn caca_dither_bitmap(&self, cv: *mut caca_canvas_t, x: libc::c_int, y: libc::c_int, + w: libc::c_int, h: libc::c_int, d: *const caca_dither_t, + pixels: *const libc::c_void) -> libc::c_int + { + (self.caca_dither_bitmap)(cv, x, y, w, h, d, pixels) + } + + pub unsafe fn caca_free_dither(&self, d: *mut caca_dither_t) -> libc::c_int { + (self.caca_free_dither)(d) + } + + pub unsafe fn caca_create_dither(&self, bpp: libc::c_int, w: libc::c_int, h: libc::c_int, + pitch: libc::c_int, rmask: libc::uint32_t, gmask: libc::uint32_t, + bmask: libc::uint32_t, amask: libc::uint32_t) -> *mut caca_dither_t + { + (self.caca_create_dither)(bpp, w, h, pitch, rmask, gmask, bmask, amask) + } + + pub unsafe fn caca_get_canvas_width(&self, cv: *mut caca_canvas_t) -> libc::c_int { + (self.caca_get_canvas_width)(cv) + } + + pub unsafe fn caca_get_canvas_height(&self, cv: *mut caca_canvas_t) -> libc::c_int { + (self.caca_get_canvas_height)(cv) + } +} + +impl Drop for LibCaca { + fn drop(&mut self) { + unsafe { dlopen::dlclose(self.lib); } + } +} diff --git a/src/api/caca/mod.rs b/src/api/caca/mod.rs new file mode 100644 index 0000000..6888e49 --- /dev/null +++ b/src/api/caca/mod.rs @@ -0,0 +1,241 @@ +#![cfg(all(any(target_os = "linux", target_os = "freebsd"), feature="headless"))] + +use libc; +use api::osmesa::OsMesaContext; + +use BuilderAttribs; +use CreationError; +use Event; +use PixelFormat; +use CursorState; +use MouseCursor; + +use std::collections::VecDeque; +use std::ptr; + +mod libcaca; + +pub struct Window { + libcaca: libcaca::LibCaca, + display: *mut libcaca::caca_display_t, + opengl: OsMesaContext, + dither: *mut libcaca::caca_dither_t, +} + +#[derive(Clone)] +pub struct WindowProxy; + +impl WindowProxy { + pub fn wakeup_event_loop(&self) { + unimplemented!() + } +} + +pub struct MonitorID; + +pub fn get_available_monitors() -> VecDeque<MonitorID> { + VecDeque::new() +} +pub fn get_primary_monitor() -> MonitorID { + MonitorID +} + +impl MonitorID { + pub fn get_name(&self) -> Option<String> { + unimplemented!(); + } + + pub fn get_native_identifier(&self) -> ::native_monitor::NativeMonitorId { + ::native_monitor::NativeMonitorId::Unavailable + } + + pub fn get_dimensions(&self) -> (u32, u32) { + unimplemented!(); + } +} + +pub struct PollEventsIterator<'a> { + window: &'a Window, +} + +impl<'a> Iterator for PollEventsIterator<'a> { + type Item = Event; + + fn next(&mut self) -> Option<Event> { + None + } +} + +pub struct WaitEventsIterator<'a> { + window: &'a Window, +} + +impl<'a> Iterator for WaitEventsIterator<'a> { + type Item = Event; + + fn next(&mut self) -> Option<Event> { + loop {} + } +} + +impl Window { + pub fn new(builder: BuilderAttribs) -> Result<Window, CreationError> { + let opengl = try!(OsMesaContext::new(builder)); + let opengl_dimensions = opengl.get_dimensions(); + + let libcaca = match libcaca::LibCaca::open() { + Err(_) => return Err(CreationError::NotSupported), + Ok(l) => l + }; + + let display = unsafe { libcaca.caca_create_display(ptr::null_mut()) }; + + if display.is_null() { + return Err(CreationError::OsError("caca_create_display failed".to_string())); + } + + let dither = unsafe { + #[cfg(target_endian = "little")] + fn get_masks() -> (u32, u32, u32, u32) { (0xff, 0xff00, 0xff0000, 0xff000000) } + #[cfg(target_endian = "big")] + fn get_masks() -> (u32, u32, u32, u32) { (0xff000000, 0xff0000, 0xff00, 0xff) } + + let masks = get_masks(); + libcaca.caca_create_dither(32, opengl_dimensions.0 as libc::c_int, + opengl_dimensions.1 as libc::c_int, + opengl_dimensions.0 as libc::c_int * 4, + masks.0, masks.1, masks.2, masks.3) + }; + + if dither.is_null() { + unsafe { libcaca.caca_free_display(display) }; + return Err(CreationError::OsError("caca_create_dither failed".to_string())); + } + + Ok(Window { + libcaca: libcaca, + display: display, + opengl: opengl, + dither: dither, + }) + } + + pub fn is_closed(&self) -> bool { + false + } + + pub fn set_title(&self, title: &str) { + } + + pub fn show(&self) { + } + + pub fn hide(&self) { + } + + pub fn get_position(&self) -> Option<(i32, i32)> { + unimplemented!() + } + + pub fn set_position(&self, x: i32, y: i32) { + } + + pub fn get_inner_size(&self) -> Option<(u32, u32)> { + Some(self.opengl.get_dimensions()) + } + + pub fn get_outer_size(&self) -> Option<(u32, u32)> { + self.get_inner_size() + } + + pub fn set_inner_size(&self, _x: u32, _y: u32) { + unimplemented!() + } + + pub fn create_window_proxy(&self) -> WindowProxy { + unimplemented!() + } + + pub fn poll_events(&self) -> PollEventsIterator { + PollEventsIterator { + window: self + } + } + + pub fn wait_events(&self) -> WaitEventsIterator { + WaitEventsIterator { + window: self + } + } + + pub unsafe fn make_current(&self) { + self.opengl.make_current() + } + + pub fn is_current(&self) -> bool { + self.opengl.is_current() + } + + pub fn get_proc_address(&self, addr: &str) -> *const () { + self.opengl.get_proc_address(addr) as *const _ + } + + pub fn swap_buffers(&self) { + unsafe { + let canvas = self.libcaca.caca_get_canvas(self.display); + let width = self.libcaca.caca_get_canvas_width(canvas); + let height = self.libcaca.caca_get_canvas_height(canvas); + + let buffer = self.opengl.get_framebuffer().chunks(self.opengl.get_dimensions().0 as usize) + .flat_map(|i| i.iter().cloned()).rev().collect::<Vec<u32>>(); + + self.libcaca.caca_dither_bitmap(canvas, 0, 0, width as libc::c_int, + height as libc::c_int, self.dither, + buffer.as_ptr() as *const _); + self.libcaca.caca_refresh_display(self.display); + }; + } + + pub fn platform_display(&self) -> *mut libc::c_void { + unimplemented!() + } + + pub fn platform_window(&self) -> *mut libc::c_void { + unimplemented!() + } + + pub fn get_api(&self) -> ::Api { + self.opengl.get_api() + } + + pub fn get_pixel_format(&self) -> PixelFormat { + unimplemented!(); + } + + pub fn set_window_resize_callback(&mut self, _: Option<fn(u32, u32)>) { + } + + pub fn set_cursor(&self, cursor: MouseCursor) { + } + + pub fn set_cursor_state(&self, state: CursorState) -> Result<(), String> { + Ok(()) + } + + pub fn hidpi_factor(&self) -> f32 { + 1.0 + } + + pub fn set_cursor_position(&self, x: i32, y: i32) -> Result<(), ()> { + Ok(()) + } +} + +impl Drop for Window { + fn drop(&mut self) { + unsafe { + self.libcaca.caca_free_dither(self.dither); + self.libcaca.caca_free_display(self.display); + } + } +} diff --git a/src/api/mod.rs b/src/api/mod.rs index 34ef01d..b8cf9de 100644 --- a/src/api/mod.rs +++ b/src/api/mod.rs @@ -1,4 +1,5 @@ pub mod android; +pub mod caca; pub mod cocoa; pub mod dlopen; pub mod egl; diff --git a/src/api/osmesa/mod.rs b/src/api/osmesa/mod.rs index 585ce72..ea90583 100644 --- a/src/api/osmesa/mod.rs +++ b/src/api/osmesa/mod.rs @@ -35,6 +35,14 @@ impl OsMesaContext { }) } + pub fn get_framebuffer(&self) -> &[u32] { + &self.buffer + } + + pub fn get_dimensions(&self) -> (u32, u32) { + (self.width, self.height) + } + pub unsafe fn make_current(&self) { let ret = osmesa_sys::OSMesaMakeCurrent(self.context, self.buffer.as_ptr() as *mut libc::c_void, |