diff options
| -rw-r--r-- | src/api/win32/init.rs | 30 | ||||
| -rw-r--r-- | src/api/win32/mod.rs | 5 | ||||
| -rw-r--r-- | src/platform/windows/mod.rs | 119 |
3 files changed, 122 insertions, 32 deletions
diff --git a/src/api/win32/init.rs b/src/api/win32/init.rs index fdb88c9..e6f0648 100644 --- a/src/api/win32/init.rs +++ b/src/api/win32/init.rs @@ -32,6 +32,7 @@ use api::wgl; use api::wgl::Context as WglContext; use api::egl; use api::egl::Context as EglContext; +use api::egl::ffi::egl::Egl; pub enum RawContext { Egl(egl::ffi::egl::types::EGLContext), @@ -41,9 +42,12 @@ pub enum RawContext { unsafe impl Send for RawContext {} unsafe impl Sync for RawContext {} -pub fn new_window(builder: BuilderAttribs<'static>, builder_sharelists: Option<RawContext>) +pub fn new_window(builder: BuilderAttribs<'static>, builder_sharelists: Option<RawContext>, + egl: Option<&Egl>) -> Result<Window, CreationError> { + let egl = egl.map(|e| e.clone()); + // initializing variables to be sent to the task let title = OsStr::new(&builder.title).encode_wide().chain(Some(0).into_iter()) @@ -56,7 +60,7 @@ pub fn new_window(builder: BuilderAttribs<'static>, builder_sharelists: Option<R thread::spawn(move || { unsafe { // creating and sending the `Window` - match init(title, builder, builder_sharelists) { + match init(title, builder, builder_sharelists, egl) { Ok(w) => tx.send(Ok(w)).ok(), Err(e) => { tx.send(Err(e)).ok(); @@ -83,7 +87,8 @@ pub fn new_window(builder: BuilderAttribs<'static>, builder_sharelists: Option<R } unsafe fn init(title: Vec<u16>, builder: BuilderAttribs<'static>, - builder_sharelists: Option<RawContext>) -> Result<Window, CreationError> + builder_sharelists: Option<RawContext>, egl: Option<Egl>) + -> Result<Window, CreationError> { // registering the window class let class_name = register_window_class(); @@ -159,24 +164,7 @@ unsafe fn init(title: Vec<u16>, builder: BuilderAttribs<'static>, // creating the OpenGL context let context = match builder.gl_version { GlRequest::Specific(Api::OpenGlEs, (major, minor)) => { - // trying to load EGL from the ATI drivers - - // TODO: use LoadLibraryA instead - let dll_name = if cfg!(target_pointer_width = "64") { - "atio6axx.dll" - } else { - "atioglxx.dll" - }; - let dll_name = OsStr::new(dll_name).encode_wide().chain(Some(0).into_iter()) - .collect::<Vec<_>>(); - let dll = unsafe { kernel32::LoadLibraryW(dll_name.as_ptr()) }; - - if !dll.is_null() { - let egl = ::api::egl::ffi::egl::Egl::load_with(|name| { - let name = CString::new(name).unwrap(); - unsafe { kernel32::GetProcAddress(dll, name.as_ptr()) as *const libc::c_void } - }); - + if let Some(egl) = egl { if let Ok(c) = EglContext::new(egl, &builder, Some(ptr::null())) .and_then(|p| p.finish(real_window.0)) { diff --git a/src/api/win32/mod.rs b/src/api/win32/mod.rs index d21f16d..9b03f64 100644 --- a/src/api/win32/mod.rs +++ b/src/api/win32/mod.rs @@ -29,6 +29,7 @@ use kernel32; use api::wgl; use api::wgl::Context as WglContext; use api::egl::Context as EglContext; +use api::egl::ffi::egl::Egl; use self::init::RawContext; @@ -84,7 +85,7 @@ impl WindowProxy { impl Window { /// See the docs in the crate root file. - pub fn new(builder: BuilderAttribs) -> Result<Window, CreationError> { + pub fn new(builder: BuilderAttribs, egl: Option<&Egl>) -> Result<Window, CreationError> { let (builder, sharing) = builder.extract_non_static(); let sharing = sharing.map(|w| match w.context { @@ -92,7 +93,7 @@ impl Window { Context::Egl(_) => unimplemented!(), // FIXME: }); - init::new_window(builder, sharing) + init::new_window(builder, sharing, egl) } /// See the docs in the crate root file. diff --git a/src/platform/windows/mod.rs b/src/platform/windows/mod.rs index b33b8ee..cf63784 100644 --- a/src/platform/windows/mod.rs +++ b/src/platform/windows/mod.rs @@ -1,6 +1,8 @@ #![cfg(target_os = "windows")] -pub use api::win32::*; +pub use api::win32; +pub use api::win32::{MonitorID, get_available_monitors, get_primary_monitor}; +pub use api::win32::{WindowProxy, PollEventsIterator, WaitEventsIterator}; use libc; @@ -11,38 +13,137 @@ use CreationError; use PixelFormat; use GlContext; +use api::egl::ffi::egl::Egl; +use api::egl::Context as EglContext; + +use std::ffi::CString; +use std::ops::{Deref, DerefMut}; +use kernel32; + +/// Stupid wrapper because `*const libc::c_void` doesn't implement `Sync`. +struct EglWrapper(Egl); +unsafe impl Sync for EglWrapper {} + +lazy_static! { + // An EGL implementation available on the system. + static ref EGL: Option<EglWrapper> = { + // the ATI drivers provide an EGL implementation in their DLLs + let dll_name = if cfg!(target_pointer_width = "64") { + b"atio6axx.dll\0" + } else { + b"atioglxx.dll\0" + }; + + let dll = unsafe { kernel32::LoadLibraryA(dll_name.as_ptr() as *const _) }; + + if !dll.is_null() { + let egl = Egl::load_with(|name| { + let name = CString::new(name).unwrap(); + unsafe { kernel32::GetProcAddress(dll, name.as_ptr()) as *const _ } + }); + + Some(EglWrapper(egl)) + + } else { + None + } + }; +} + + +/// The Win32 implementation of the main `Window` object. +pub struct Window(win32::Window); + +impl Window { + /// See the docs in the crate root file. + pub fn new(builder: BuilderAttribs) -> Result<Window, CreationError> { + win32::Window::new(builder, EGL.as_ref().map(|w| &w.0)).map(|w| Window(w)) + } +} + +impl Deref for Window { + type Target = win32::Window; + + fn deref(&self) -> &win32::Window { + &self.0 + } +} + +impl DerefMut for Window { + fn deref_mut(&mut self) -> &mut win32::Window { + &mut self.0 + } +} + /// -pub struct HeadlessContext(Window); +pub enum HeadlessContext { + /// A regular window, but invisible. + HiddenWindow(win32::Window), + /// An EGL pbuffer. + EglPbuffer(EglContext), +} impl HeadlessContext { pub fn new(mut builder: BuilderAttribs) -> Result<HeadlessContext, CreationError> { builder.visible = false; - Window::new(builder).map(|w| HeadlessContext(w)) + + // if EGL is available, we try using EGL first + // if EGL returns an error, we try the hidden window method + if let &Some(ref egl) = &*EGL { + let context = EglContext::new(egl.0.clone(), &builder, None) + .and_then(|prototype| prototype.finish_pbuffer()) + .map(|ctxt| HeadlessContext::EglPbuffer(ctxt)); + + if let Ok(context) = context { + return Ok(context); + } + } + + let window = try!(win32::Window::new(builder, EGL.as_ref().map(|w| &w.0))); + Ok(HeadlessContext::HiddenWindow(window)) } } impl GlContext for HeadlessContext { unsafe fn make_current(&self) -> Result<(), ContextError> { - self.0.make_current() + match self { + &HeadlessContext::HiddenWindow(ref ctxt) => ctxt.make_current(), + &HeadlessContext::EglPbuffer(ref ctxt) => ctxt.make_current(), + } } fn is_current(&self) -> bool { - self.0.is_current() + match self { + &HeadlessContext::HiddenWindow(ref ctxt) => ctxt.is_current(), + &HeadlessContext::EglPbuffer(ref ctxt) => ctxt.is_current(), + } } fn get_proc_address(&self, addr: &str) -> *const libc::c_void { - self.0.get_proc_address(addr) + match self { + &HeadlessContext::HiddenWindow(ref ctxt) => ctxt.get_proc_address(addr), + &HeadlessContext::EglPbuffer(ref ctxt) => ctxt.get_proc_address(addr), + } } fn swap_buffers(&self) -> Result<(), ContextError> { - self.0.swap_buffers() + match self { + &HeadlessContext::HiddenWindow(ref ctxt) => ctxt.swap_buffers(), + &HeadlessContext::EglPbuffer(ref ctxt) => ctxt.swap_buffers(), + } } fn get_api(&self) -> Api { - self.0.get_api() + match self { + &HeadlessContext::HiddenWindow(ref ctxt) => ctxt.get_api(), + &HeadlessContext::EglPbuffer(ref ctxt) => ctxt.get_api(), + } } fn get_pixel_format(&self) -> PixelFormat { - self.0.get_pixel_format() + match self { + &HeadlessContext::HiddenWindow(ref ctxt) => ctxt.get_pixel_format(), + &HeadlessContext::EglPbuffer(ref ctxt) => ctxt.get_pixel_format(), + } } } |