aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/api/android/mod.rs40
-rw-r--r--src/api/win32/init.rs30
-rw-r--r--src/api/win32/mod.rs5
-rw-r--r--src/api/x11/xdisplay.rs5
-rw-r--r--src/platform/android/mod.rs33
-rw-r--r--src/platform/windows/mod.rs119
6 files changed, 166 insertions, 66 deletions
diff --git a/src/api/android/mod.rs b/src/api/android/mod.rs
index 83ef12b..7c09a7b 100644
--- a/src/api/android/mod.rs
+++ b/src/api/android/mod.rs
@@ -249,3 +249,43 @@ impl WindowProxy {
unimplemented!()
}
}
+
+pub struct HeadlessContext(EglContext);
+
+impl HeadlessContext {
+ /// See the docs in the crate root file.
+ pub fn new(builder: BuilderAttribs) -> Result<HeadlessContext, CreationError> {
+ let context = try!(EglContext::new(egl::ffi::egl::Egl, &builder, None));
+ let context = try!(context.finish_pbuffer());
+ Ok(context)
+ }
+}
+
+unsafe impl Send for HeadlessContext {}
+unsafe impl Sync for HeadlessContext {}
+
+impl GlContext for HeadlessContext {
+ unsafe fn make_current(&self) -> Result<(), ContextError> {
+ self.0.make_current()
+ }
+
+ fn is_current(&self) -> bool {
+ self.0.is_current()
+ }
+
+ fn get_proc_address(&self, addr: &str) -> *const libc::c_void {
+ self.0.get_proc_address(addr)
+ }
+
+ fn swap_buffers(&self) -> Result<(), ContextError> {
+ self.0.swap_buffers()
+ }
+
+ fn get_api(&self) -> Api {
+ self.0.get_api()
+ }
+
+ fn get_pixel_format(&self) -> PixelFormat {
+ self.0.get_pixel_format()
+ }
+}
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/api/x11/xdisplay.rs b/src/api/x11/xdisplay.rs
index 2576b74..c960c00 100644
--- a/src/api/x11/xdisplay.rs
+++ b/src/api/x11/xdisplay.rs
@@ -63,7 +63,10 @@ impl XConnection {
// TODO: use something safer than raw "dlopen"
let egl = {
- let libegl = unsafe { dlopen::dlopen(b"libEGL.so\0".as_ptr() as *const _, dlopen::RTLD_NOW) };
+ let mut libegl = unsafe { dlopen::dlopen(b"libEGL.so.1\0".as_ptr() as *const _, dlopen::RTLD_NOW) };
+ if libegl.is_null() {
+ libegl = unsafe { dlopen::dlopen(b"libEGL.so\0".as_ptr() as *const _, dlopen::RTLD_NOW) };
+ }
if libegl.is_null() {
None
diff --git a/src/platform/android/mod.rs b/src/platform/android/mod.rs
index 50f554b..c90d8ce 100644
--- a/src/platform/android/mod.rs
+++ b/src/platform/android/mod.rs
@@ -1,36 +1,3 @@
#![cfg(target_os = "android")]
pub use api::android::*;
-
-use ContextError;
-
-pub struct HeadlessContext(i32);
-
-impl HeadlessContext {
- /// See the docs in the crate root file.
- pub fn new(_builder: BuilderAttribs) -> Result<HeadlessContext, CreationError> {
- unimplemented!()
- }
-
- /// See the docs in the crate root file.
- pub unsafe fn make_current(&self) -> Result<(), ContextError> {
- unimplemented!()
- }
-
- /// See the docs in the crate root file.
- pub fn is_current(&self) -> bool {
- unimplemented!()
- }
-
- /// See the docs in the crate root file.
- pub fn get_proc_address(&self, _addr: &str) -> *const () {
- unimplemented!()
- }
-
- pub fn get_api(&self) -> ::Api {
- ::Api::OpenGlEs
- }
-}
-
-unsafe impl Send for HeadlessContext {}
-unsafe impl Sync for HeadlessContext {}
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(),
+ }
}
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-28 04:32:56 +0000