From 587dedaa9e95236f891d9a0e4ec04ee3700236a8 Mon Sep 17 00:00:00 2001 From: Pierre Krieger Date: Fri, 7 Aug 2015 16:22:31 +0200 Subject: Correctly handle eglGetDisplay --- build.rs | 40 ++++++++++++++++- src/api/android/mod.rs | 4 +- src/api/egl/mod.rs | 102 ++++++++++++++++++++++++++++++++++++++------ src/api/wayland/mod.rs | 3 +- src/api/win32/init.rs | 5 ++- src/api/x11/window.rs | 5 ++- src/platform/windows/mod.rs | 3 +- 7 files changed, 139 insertions(+), 23 deletions(-) diff --git a/build.rs b/build.rs index c73f687..51f86aa 100644 --- a/build.rs +++ b/build.rs @@ -46,6 +46,15 @@ fn main() { "EGL_KHR_create_context".to_string(), "EGL_EXT_create_context_robustness".to_string(), "EGL_KHR_create_context_no_error".to_string(), + "EGL_KHR_platform_x11".to_string(), + "EGL_KHR_platform_android".to_string(), + "EGL_KHR_platform_wayland".to_string(), + "EGL_KHR_platform_gbm".to_string(), + "EGL_EXT_platform_base".to_string(), + "EGL_EXT_platform_x11".to_string(), + "EGL_MESA_platform_gbm".to_string(), + "EGL_EXT_platform_wayland".to_string(), + "EGL_EXT_platform_device".to_string(), ], "1.5", "core", &mut file).unwrap(); } @@ -83,6 +92,15 @@ fn main() { "EGL_KHR_create_context".to_string(), "EGL_EXT_create_context_robustness".to_string(), "EGL_KHR_create_context_no_error".to_string(), + "EGL_KHR_platform_x11".to_string(), + "EGL_KHR_platform_android".to_string(), + "EGL_KHR_platform_wayland".to_string(), + "EGL_KHR_platform_gbm".to_string(), + "EGL_EXT_platform_base".to_string(), + "EGL_EXT_platform_x11".to_string(), + "EGL_MESA_platform_gbm".to_string(), + "EGL_EXT_platform_wayland".to_string(), + "EGL_EXT_platform_device".to_string(), ], "1.5", "core", &mut file).unwrap(); } @@ -97,6 +115,15 @@ fn main() { "EGL_KHR_create_context".to_string(), "EGL_EXT_create_context_robustness".to_string(), "EGL_KHR_create_context_no_error".to_string(), + "EGL_KHR_platform_x11".to_string(), + "EGL_KHR_platform_android".to_string(), + "EGL_KHR_platform_wayland".to_string(), + "EGL_KHR_platform_gbm".to_string(), + "EGL_EXT_platform_base".to_string(), + "EGL_EXT_platform_x11".to_string(), + "EGL_MESA_platform_gbm".to_string(), + "EGL_EXT_platform_wayland".to_string(), + "EGL_EXT_platform_device".to_string(), ], "1.5", "core", &mut file).unwrap(); } @@ -108,7 +135,18 @@ fn main() { gl_generator::Fallbacks::All, khronos_api::EGL_XML, vec![ - "EGL_KHR_create_context".to_string() + "EGL_KHR_create_context".to_string(), + "EGL_EXT_create_context_robustness".to_string(), + "EGL_KHR_create_context_no_error".to_string(), + "EGL_KHR_platform_x11".to_string(), + "EGL_KHR_platform_android".to_string(), + "EGL_KHR_platform_wayland".to_string(), + "EGL_KHR_platform_gbm".to_string(), + "EGL_EXT_platform_base".to_string(), + "EGL_EXT_platform_x11".to_string(), + "EGL_MESA_platform_gbm".to_string(), + "EGL_EXT_platform_wayland".to_string(), + "EGL_EXT_platform_device".to_string(), ], "1.5", "core", &mut file).unwrap(); diff --git a/src/api/android/mod.rs b/src/api/android/mod.rs index 7c09a7b..1b52cc0 100644 --- a/src/api/android/mod.rs +++ b/src/api/android/mod.rs @@ -112,7 +112,7 @@ impl Window { return Err(OsError(format!("Android's native window is null"))); } - let context = try!(EglContext::new(egl::ffi::egl::Egl, &builder, None) + let context = try!(EglContext::new(egl::ffi::egl::Egl, &builder, egl::NativeDisplay::Android) .and_then(|p| p.finish(native_window as *const _))); let (tx, rx) = channel(); @@ -255,7 +255,7 @@ pub struct HeadlessContext(EglContext); impl HeadlessContext { /// See the docs in the crate root file. pub fn new(builder: BuilderAttribs) -> Result { - let context = try!(EglContext::new(egl::ffi::egl::Egl, &builder, None)); + let context = try!(EglContext::new(egl::ffi::egl::Egl, &builder, egl::NativeDisplay::Android)); let context = try!(context.finish_pbuffer()); Ok(context) } diff --git a/src/api/egl/mod.rs b/src/api/egl/mod.rs index 83cd009..f6757ac 100644 --- a/src/api/egl/mod.rs +++ b/src/api/egl/mod.rs @@ -16,6 +16,22 @@ use std::{mem, ptr}; pub mod ffi; +/// Specifies the type of display passed as `native_display`. +pub enum NativeDisplay { + /// `None` means `EGL_DEFAULT_DISPLAY`. + X11(Option), + /// `None` means `EGL_DEFAULT_DISPLAY`. + Gbm(Option), + /// `None` means `EGL_DEFAULT_DISPLAY`. + Wayland(Option), + /// `EGL_DEFAULT_DISPLAY` is mandatory for Android. + Android, + // TODO: should be `EGLDeviceEXT` + Device(ffi::EGLNativeDisplayType), + /// Don't specify any display type. Useful on windows. `None` means `EGL_DEFAULT_DISPLAY`. + Other(Option), +} + pub struct Context { egl: ffi::egl::Egl, display: ffi::egl::types::EGLDisplay, @@ -32,7 +48,7 @@ impl Context { /// /// To finish the process, you must call `.finish(window)` on the `ContextPrototype`. pub fn new<'a>(egl: ffi::egl::Egl, builder: &'a BuilderAttribs<'a>, - native_display: Option) + native_display: NativeDisplay) -> Result, CreationError> { if builder.sharing.is_some() { @@ -40,28 +56,88 @@ impl Context { } // the first step is to query the list of extensions without any display, if supported - let extensions = unsafe { + let dp_extensions = unsafe { let p = egl.QueryString(ffi::egl::NO_DISPLAY, ffi::egl::EXTENSIONS as i32); // this possibility is available only with EGL 1.5 or EGL_EXT_platform_base, otherwise // `eglQueryString` returns an error if p.is_null() { - None + vec![] } else { let p = CStr::from_ptr(p); let list = String::from_utf8(p.to_bytes().to_vec()).unwrap_or_else(|_| format!("")); - Some(list.split(' ').map(|e| e.to_string()).collect::>()) + list.split(' ').map(|e| e.to_string()).collect::>() } }; - let display = unsafe { - let display = egl.GetDisplay(native_display.unwrap_or(mem::transmute(ffi::egl::DEFAULT_DISPLAY))); - if display.is_null() { - return Err(CreationError::OsError("No EGL display connection available".to_string())); + let has_dp_extension = |e: &str| dp_extensions.iter().find(|s| s == &e).is_some(); + + // calling `eglGetDisplay` or equivalent + let display = match native_display { + NativeDisplay::X11(display) if has_dp_extension("EGL_KHR_platform_x11") => { + let d = display.unwrap_or(ffi::egl::DEFAULT_DISPLAY as *const _); + // TODO: `PLATFORM_X11_SCREEN_KHR` + unsafe { egl.GetPlatformDisplay(ffi::egl::PLATFORM_X11_KHR, d as *mut _, + ptr::null()) } + }, + + NativeDisplay::X11(display) if has_dp_extension("EGL_EXT_platform_x11") => { + let d = display.unwrap_or(ffi::egl::DEFAULT_DISPLAY as *const _); + // TODO: `PLATFORM_X11_SCREEN_EXT` + unsafe { egl.GetPlatformDisplayEXT(ffi::egl::PLATFORM_X11_EXT, d as *mut _, + ptr::null()) } + }, + + NativeDisplay::Gbm(display) if has_dp_extension("EGL_KHR_platform_gbm") => { + let d = display.unwrap_or(ffi::egl::DEFAULT_DISPLAY as *const _); + unsafe { egl.GetPlatformDisplay(ffi::egl::PLATFORM_GBM_KHR, d as *mut _, + ptr::null()) } + }, + + NativeDisplay::Gbm(display) if has_dp_extension("EGL_MESA_platform_gbm") => { + let d = display.unwrap_or(ffi::egl::DEFAULT_DISPLAY as *const _); + unsafe { egl.GetPlatformDisplayEXT(ffi::egl::PLATFORM_GBM_KHR, d as *mut _, + ptr::null()) } + }, + + NativeDisplay::Wayland(display) if has_dp_extension("EGL_KHR_platform_wayland") => { + let d = display.unwrap_or(ffi::egl::DEFAULT_DISPLAY as *const _); + unsafe { egl.GetPlatformDisplay(ffi::egl::PLATFORM_WAYLAND_KHR, d as *mut _, + ptr::null()) } + }, + + NativeDisplay::Wayland(display) if has_dp_extension("EGL_EXT_platform_wayland") => { + let d = display.unwrap_or(ffi::egl::DEFAULT_DISPLAY as *const _); + unsafe { egl.GetPlatformDisplayEXT(ffi::egl::PLATFORM_WAYLAND_EXT, d as *mut _, + ptr::null()) } + }, + + NativeDisplay::Android if has_dp_extension("EGL_KHR_platform_android") => { + unsafe { egl.GetPlatformDisplay(ffi::egl::PLATFORM_ANDROID_KHR, + ffi::egl::DEFAULT_DISPLAY as *mut _, ptr::null()) } + }, + + NativeDisplay::Device(display) if has_dp_extension("EGL_EXT_platform_device") => { + unsafe { egl.GetPlatformDisplay(ffi::egl::PLATFORM_DEVICE_EXT, display as *mut _, + ptr::null()) } + }, + + NativeDisplay::X11(Some(display)) | NativeDisplay::Gbm(Some(display)) | + NativeDisplay::Wayland(Some(display)) | NativeDisplay::Device(display) | + NativeDisplay::Other(Some(display)) => { + unsafe { egl.GetDisplay(display as *mut _) } } - display + + NativeDisplay::X11(None) | NativeDisplay::Gbm(None) | NativeDisplay::Wayland(None) | + NativeDisplay::Android | NativeDisplay::Other(None) => { + unsafe { egl.GetDisplay(ffi::egl::DEFAULT_DISPLAY as *mut _) } + }, }; + if display.is_null() { + return Err(CreationError::OsError("Could not create EGL display object".to_string())); + } + let egl_version = unsafe { let mut major: ffi::egl::types::EGLint = mem::uninitialized(); let mut minor: ffi::egl::types::EGLint = mem::uninitialized(); @@ -73,11 +149,9 @@ impl Context { (major, minor) }; - // getting the list of extensions for real - let extensions = if let Some(extensions) = extensions { - extensions - - } else if egl_version >= (1, 2) { + // the list of extensions supported by the client once initialized is different from the + // list of extensions obtained earlier + let extensions = if egl_version >= (1, 2) { let p = unsafe { CStr::from_ptr(egl.QueryString(display, ffi::egl::EXTENSIONS as i32)) }; let list = String::from_utf8(p.to_bytes().to_vec()).unwrap_or_else(|_| format!("")); list.split(' ').map(|e| e.to_string()).collect::>() diff --git a/src/api/wayland/mod.rs b/src/api/wayland/mod.rs index 826826e..77ebc16 100644 --- a/src/api/wayland/mod.rs +++ b/src/api/wayland/mod.rs @@ -8,6 +8,7 @@ use self::wayland::core::shell::{ShellSurface, ShellFullscreenMethod}; use libc; use api::dlopen; +use api::egl; use api::egl::Context as EglContext; use BuilderAttribs; @@ -169,7 +170,7 @@ impl Window { try!(EglContext::new( egl, &builder, - Some(wayland_context.display.ptr() as *const _)) + egl::NativeDisplay::Wayland(Some(wayland_context.display.ptr() as *const _))) .and_then(|p| p.finish((*shell_surface).ptr() as *const _)) ) }; diff --git a/src/api/win32/init.rs b/src/api/win32/init.rs index e6f0648..6ce36d0 100644 --- a/src/api/win32/init.rs +++ b/src/api/win32/init.rs @@ -165,8 +165,9 @@ unsafe fn init(title: Vec, builder: BuilderAttribs<'static>, let context = match builder.gl_version { GlRequest::Specific(Api::OpenGlEs, (major, minor)) => { if let Some(egl) = egl { - if let Ok(c) = EglContext::new(egl, &builder, Some(ptr::null())) - .and_then(|p| p.finish(real_window.0)) + if let Ok(c) = EglContext::new(egl, &builder, + egl::NativeDisplay::Other(Some(ptr::null()))) + .and_then(|p| p.finish(real_window.0)) { Context::Egl(c) diff --git a/src/api/x11/window.rs b/src/api/x11/window.rs index fc8ed5c..a395242 100644 --- a/src/api/x11/window.rs +++ b/src/api/x11/window.rs @@ -17,6 +17,7 @@ use GlRequest; use PixelFormat; use api::glx::Context as GlxContext; +use api::egl; use api::egl::Context as EglContext; use platform::MonitorID as PlatformMonitorID; @@ -335,7 +336,7 @@ impl Window { let context = match builder.gl_version { GlRequest::Latest | GlRequest::Specific(Api::OpenGl, _) | GlRequest::GlThenGles { .. } => { if let Some(ref egl) = display.egl { - Prototype::Egl(try!(EglContext::new(egl.clone(), &builder_clone, Some(display.display as *const _)))) + Prototype::Egl(try!(EglContext::new(egl.clone(), &builder_clone, egl::NativeDisplay::X11(Some(display.display as *const _))))) } else if let Some(ref glx) = display.glx { Prototype::Glx(try!(GlxContext::new(glx.clone(), &display.xlib, &builder_clone, display.display))) } else { @@ -344,7 +345,7 @@ impl Window { }, GlRequest::Specific(Api::OpenGlEs, _) => { if let Some(ref egl) = display.egl { - Prototype::Egl(try!(EglContext::new(egl.clone(), &builder_clone, Some(display.display as *const _)))) + Prototype::Egl(try!(EglContext::new(egl.clone(), &builder_clone, egl::NativeDisplay::X11(Some(display.display as *const _))))) } else { return Err(CreationError::NotSupported); } diff --git a/src/platform/windows/mod.rs b/src/platform/windows/mod.rs index cf63784..7087a23 100644 --- a/src/platform/windows/mod.rs +++ b/src/platform/windows/mod.rs @@ -14,6 +14,7 @@ use PixelFormat; use GlContext; use api::egl::ffi::egl::Egl; +use api::egl; use api::egl::Context as EglContext; use std::ffi::CString; @@ -90,7 +91,7 @@ impl HeadlessContext { // 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) + let context = EglContext::new(egl.0.clone(), &builder, egl::NativeDisplay::Other(None)) .and_then(|prototype| prototype.finish_pbuffer()) .map(|ctxt| HeadlessContext::EglPbuffer(ctxt)); -- cgit v1.2.3