Correctly handle eglGetDisplay

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();
 

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<HeadlessContext, CreationError> {
-        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)
     }

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<ffi::EGLNativeDisplayType>),
+    /// `None` means `EGL_DEFAULT_DISPLAY`.
+    Gbm(Option<ffi::EGLNativeDisplayType>),
+    /// `None` means `EGL_DEFAULT_DISPLAY`.
+    Wayland(Option<ffi::EGLNativeDisplayType>),
+    /// `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<ffi::EGLNativeDisplayType>),
+}
+
 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<ffi::EGLNativeDisplayType>)
+                   native_display: NativeDisplay)
                    -> Result<ContextPrototype<'a>, 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::<Vec<_>>())
+                list.split(' ').map(|e| e.to_string()).collect::<Vec<_>>()
             }
         };
 
-        let display = unsafe {
+        let has_dp_extension = |e: &str| dp_extensions.iter().find(|s| s == &e).is_some();
-            let display = egl.GetDisplay(native_display.unwrap_or(mem::transmute(ffi::egl::DEFAULT_DISPLAY)));
+
-            if display.is_null() {
+        // calling `eglGetDisplay` or equivalent
-                return Err(CreationError::OsError("No EGL display connection available".to_string()));
+        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
+        // the list of extensions supported by the client once initialized is different from the
-        let extensions = if let Some(extensions) = extensions {
+        // list of extensions obtained earlier
-            extensions
+        let extensions = if egl_version >= (1, 2) {
-
-        } else 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::<Vec<_>>()

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 _))
             )
         };

src/api/win32/init.rs

@@ -165,8 +165,9 @@ unsafe fn init(title: Vec<u16>, 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()))
+                if let Ok(c) = EglContext::new(egl, &builder,
-                                                              .and_then(|p| p.finish(real_window.0))
+                                               egl::NativeDisplay::Other(Some(ptr::null())))
+                                                             .and_then(|p| p.finish(real_window.0))
                 {
                     Context::Egl(c)
 

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);
                 }

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));