Merge branch 'EGL'

CMake/modules/FindEGL.cmake

@@ -0,0 +1,16 @@
+# Find EGL
+#
+# EGL_INCLUDE_DIR
+# EGL_LIBRARY
+# EGL_FOUND
+
+find_path(EGL_INCLUDE_DIR NAMES EGL/egl.h)
+
+set(EGL_NAMES ${EGL_NAMES} egl EGL)
+find_library(EGL_LIBRARY NAMES ${EGL_NAMES})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(EGL DEFAULT_MSG EGL_LIBRARY EGL_INCLUDE_DIR)
+
+mark_as_advanced(EGL_INCLUDE_DIR EGL_LIBRARY)
+

CMakeLists.txt

@@ -15,7 +15,20 @@ option(GLFW_BUILD_TESTS "Build the GLFW test programs" ON)
 option(GLFW_NATIVE_API "Build the GLFW native API" OFF)
 option(BUILD_SHARED_LIBS "Build shared libraries" OFF)
 
-find_package(OpenGL REQUIRED)
+if (NOT APPLE)
+    option(GLFW_USE_EGL "Use EGL for context creation" OFF)
+endif()
+
+if (GLFW_USE_EGL)
+    set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMake/modules)
+    find_package(EGL REQUIRED)
+
+    set(GLFW_BUILD_EXAMPLES OFF)
+    set(GLFW_BUILD_TESTS OFF)
+    message(STATUS "NOTE: Examples and tests are disabled for EGL")
+else()
+    find_package(OpenGL REQUIRED)
+endif()
 
 if (NOT WIN32)
     set(CMAKE_THREAD_PREFER_PTHREADS YES)
@@ -41,17 +54,40 @@ if (BUILD_SHARED_LIBS)
 endif()
 
 #--------------------------------------------------------------------
-# Detect and select target platform
+# Detect and select target APIs
 #--------------------------------------------------------------------
 if (WIN32)
-    set(_GLFW_WIN32_WGL 1)
-    message(STATUS "Building GLFW for WGL on a Win32 system") 
-elseif (UNIX AND APPLE)
-    set(_GLFW_COCOA_NSGL 1)
-    message(STATUS "Building GLFW for Cocoa and NSOpenGL on Mac OS X")
-elseif (UNIX AND NOT APPLE)
-    set(_GLFW_X11_GLX 1)
-    message(STATUS "Building GLFW for X11 and GLX on a Unix-like system")
+    set(_GLFW_WIN32 1)
+    message(STATUS "Using Win32 for window creation") 
+
+    if (GLFW_USE_EGL)
+        set(_GLFW_EGL 1)
+        message(STATUS "Using EGL for context creation")
+    else()
+        set(_GLFW_WGL 1)
+        message(STATUS "Using WGL for context creation")
+    endif()
+elseif (APPLE)
+    set(_GLFW_COCOA 1)
+    message(STATUS "Using Cocoa for window creation")
+
+    if (GLFW_USE_EGL)
+        message(FATAL_ERROR "EGL not supported on Mac OS X")
+    else()
+        set(_GLFW_NSGL 1)
+        message(STATUS "Using NSGL for context creation")
+    endif()
+elseif (UNIX)
+    set(_GLFW_X11 1)
+    message(STATUS "Using X11 for window creation") 
+
+    if (GLFW_USE_EGL)
+        set(_GLFW_EGL 1)
+        message(STATUS "Using EGL for context creation")
+    else()
+        set(_GLFW_GLX 1)
+        message(STATUS "Using GLX for context creation")
+    endif()
 else()
     message(FATAL_ERROR "No supported platform was detected")
 endif()
@@ -59,7 +95,7 @@ endif()
 #--------------------------------------------------------------------
 # Set up GLFW for Win32 and WGL on Windows
 #--------------------------------------------------------------------
-if (_GLFW_WIN32_WGL)
+if (_GLFW_WIN32)
 
     # Set up library and include paths
     list(APPEND glfw_INCLUDE_DIRS ${OPENGL_INCLUDE_DIR})
@@ -88,20 +124,18 @@ if (_GLFW_WIN32_WGL)
 endif()
 
 #--------------------------------------------------------------------
-# Set up GLFW for Xlib and GLX on Unix-like systems with X Windows
+# Set up GLFW for Xlib and GLX or EGL on Unix-like systems with X Windows
 #--------------------------------------------------------------------
-if (_GLFW_X11_GLX)
+if (_GLFW_X11)
 
     find_package(X11 REQUIRED)
 
-    # Set up library and include paths
-    list(APPEND glfw_INCLUDE_DIRS ${X11_X11_INCLUDE_PATH} ${OPENGL_INCLUDE_DIR})
-    list(APPEND glfw_LIBRARIES ${X11_X11_LIB} ${OPENGL_gl_LIBRARY})
-
-    set(GLFW_PKG_DEPS "gl x11")
     set(GLFW_PKG_LIBS "")
+    set(GLFW_PKG_DEPS "x11")
 
-    include(CheckFunctionExists)
+    # Set up library and include paths
+    list(APPEND glfw_INCLUDE_DIRS ${X11_X11_INCLUDE_PATH})
+    list(APPEND glfw_LIBRARIES ${X11_X11_LIB})
 
     # Check for XRandR (modern resolution switching extension)
     if (X11_Xrandr_FOUND)
@@ -147,6 +181,21 @@ if (_GLFW_X11_GLX)
         set(GLFW_PKG_LIBS "${GLFW_PKG_LIBS} -lm")
     endif()
 
+endif()
+
+#--------------------------------------------------------------------
+# GLX Context
+#--------------------------------------------------------------------
+if (_GLFW_GLX)
+
+    # Set up library and include paths
+    list(APPEND glfw_INCLUDE_DIRS ${OPENGL_INCLUDE_DIR})
+    list(APPEND glfw_LIBRARIES ${OPENGL_gl_LIBRARY})
+
+    set(GLFW_PKG_DEPS "${GLFW_PKG_DEPS} gl")
+
+    include(CheckFunctionExists)
+
     set(CMAKE_REQUIRED_LIBRARIES ${OPENGL_gl_LIBRARY})
 
     check_function_exists(glXGetProcAddress _GLFW_HAS_GLXGETPROCADDRESS)
@@ -185,12 +234,59 @@ if (_GLFW_X11_GLX)
             set(GLFW_PKG_LIBS "${GLFW_PKG_LIBS} -ldl")
         endif()
     endif()
+
+endif()
+
+#--------------------------------------------------------------------
+# EGL Context
+#--------------------------------------------------------------------
+if (_GLFW_EGL)
+
+    # Set up library and include paths
+    list(APPEND glfw_INCLUDE_DIRS ${EGL_INCLUDE_DIR})
+    list(APPEND glfw_LIBRARIES ${EGL_LIBRARY})
+
+    set(CMAKE_REQUIRED_LIBRARIES ${EGL_LIBRARY})
+
+    if (_GLFW_X11)
+        set(GLFW_PKG_DEPS "${GLFW_PKG_DEPS} egl")
+
+        include(CheckFunctionExists)
+
+        check_function_exists(eglGetProcAddress _GLFW_HAS_EGLGETPROCADDRESS)
+
+        if (NOT _GLFW_HAS_EGLGETPROCADDRESS)
+            message(WARNING "No eglGetProcAddress found")
+
+            # Check for dlopen support as a fallback
+
+            find_library(DL_LIBRARY dl)
+            mark_as_advanced(DL_LIBRARY)
+            if (DL_LIBRARY)
+                set(CMAKE_REQUIRED_LIBRARIES ${DL_LIBRARY})
+            else()
+                set(CMAKE_REQUIRED_LIBRARIES "")
+            endif()
+
+            check_function_exists(dlopen _GLFW_HAS_DLOPEN)
+
+            if (NOT _GLFW_HAS_DLOPEN)
+                message(FATAL_ERROR "No entry point retrieval mechanism found")
+            endif()
+
+            if (DL_LIBRARY)
+                list(APPEND glfw_LIBRARIES ${DL_LIBRARY})
+                set(GLFW_PKG_LIBS "${GLFW_PKG_LIBS} -ldl")
+            endif()
+        endif()
+    endif()
+
 endif()
 
 #--------------------------------------------------------------------
 # Set up GLFW for Cocoa and NSOpenGL on Mac OS X
 #--------------------------------------------------------------------
-if (_GLFW_COCOA_NSGL)
+if (_GLFW_COCOA AND _GLFW_NSGL)
         
     option(GLFW_BUILD_UNIVERSAL "Build GLFW as a Universal Binary" OFF)
 
@@ -272,7 +368,7 @@ install(FILES COPYING.txt readme.html
 #--------------------------------------------------------------------
 # Create and install pkg-config file on supported platforms
 #--------------------------------------------------------------------
-if (_GLFW_X11_GLX OR _GLFW_COCOA_NSGL)
+if (UNIX)
     configure_file(${GLFW_SOURCE_DIR}/src/glfw3.pc.in
                    ${GLFW_BINARY_DIR}/src/glfw3.pc @ONLY)
 

include/GL/glfw3.h

@@ -188,6 +188,10 @@ extern "C" {
 #else
   #if defined(GLFW_INCLUDE_GLCOREARB)
     #include <GL/glcorearb.h>
+  #elif defined(GLFW_INCLUDE_ES1)
+    #include <GLES/gl.h>
+  #elif defined(GLFW_INCLUDE_ES2)
+    #include <GLES2/gl2.h>
   #else
     #include <GL/gl.h>
   #endif

readme.html

@@ -285,6 +285,7 @@ version of GLFW.</p>
   <li>Added <code>GLFW_OPENGL_ROBUSTNESS</code> window hint and associated strategy tokens for <code>GL_ARB_robustness</code> support</li>
   <li>Added <code>GLFW_OPENGL_REVISION</code> window parameter to make up for removal of <code>glfwGetGLVersion</code></li>
   <li>Added <code>GLFW_INCLUDE_GLCOREARB</code> macro for including <code>glcorearb.h</code> instead of <code>gl.h</code></li>
+  <li>Added <code>GLFW_INCLUDE_ES2</code> macro for telling the GLFW header to include the OpenGL ES 2.0 header instead of <code>gl.h</code></li>
   <li>Added <code>GLFW_VISIBLE</code> window hint and parameter for controlling and polling window visibility</li>
   <li>Added <code>GLFW_POSITION_X</code> and <code>GLFW_POSITION_Y</code> window hints and parameter for controlling and polling window position</li>
   <li>Added <code>windows</code> simple multi-window test program</li>

src/CMakeLists.txt

@@ -7,41 +7,57 @@ if (MSVC)
 endif()
 
 set(common_HEADERS ${GLFW_SOURCE_DIR}/include/GL/glfw3.h internal.h)
-set(common_SOURCES clipboard.c fullscreen.c gamma.c init.c input.c
-                   joystick.c opengl.c time.c window.c)
+set(common_SOURCES clipboard.c context.c fullscreen.c gamma.c init.c input.c
+                   joystick.c time.c window.c)
 
-if (_GLFW_COCOA_NSGL)
+if (_GLFW_COCOA)
     set(glfw_HEADERS ${common_HEADERS} cocoa_platform.h)
     set(glfw_SOURCES ${common_SOURCES} cocoa_clipboard.m cocoa_fullscreen.m
-                     cocoa_gamma.c cocoa_init.m cocoa_joystick.m
-                     cocoa_opengl.m cocoa_time.c cocoa_window.m)
+                     cocoa_gamma.c cocoa_init.m cocoa_joystick.m cocoa_time.c
+                     cocoa_window.m)
 
     if (GLFW_NATIVE_API)
         list(APPEND glfw_SOURCES cocoa_native.m)
     endif()
-
-    # For some reason, CMake doesn't know about .m
-    set_source_files_properties(${glfw_SOURCES} PROPERTIES LANGUAGE C)
-elseif (_GLFW_WIN32_WGL)
+elseif (_GLFW_WIN32)
     set(glfw_HEADERS ${common_HEADERS} win32_platform.h)
     set(glfw_SOURCES ${common_SOURCES} win32_clipboard.c win32_fullscreen.c
-                     win32_gamma.c win32_init.c win32_joystick.c
-                     win32_opengl.c win32_time.c win32_window.c)
+                     win32_gamma.c win32_init.c win32_joystick.c win32_time.c
+                     win32_window.c)
 
     if (GLFW_NATIVE_API)
         list(APPEND glfw_SOURCES win32_native.c)
     endif()
-elseif (_GLFW_X11_GLX)
+elseif (_GLFW_X11)
     set(glfw_HEADERS ${common_HEADERS} x11_platform.h)
     set(glfw_SOURCES ${common_SOURCES} x11_clipboard.c x11_fullscreen.c
-                     x11_gamma.c x11_init.c x11_joystick.c
-                     x11_keysym2unicode.c x11_opengl.c x11_time.c x11_window.c)
+                     x11_gamma.c x11_init.c x11_joystick.c x11_keysym2unicode.c
+                     x11_time.c x11_window.c)
 
     if (GLFW_NATIVE_API)
         list(APPEND glfw_SOURCES x11_native.c)
     endif()
 endif()
 
+if (_GLFW_EGL)
+    list(APPEND glfw_HEADERS ${common_HEADERS} egl_platform.h)
+    list(APPEND glfw_SOURCES ${common_SOURCES} egl_context.c)
+elseif (_GLFW_NSGL)
+    list(APPEND glfw_HEADERS ${common_HEADERS} nsgl_platform.h)
+    list(APPEND glfw_SOURCES ${common_SOURCES} nsgl_context.m)
+elseif (_GLFW_WGL)
+    list(APPEND glfw_HEADERS ${common_HEADERS} wgl_platform.h)
+    list(APPEND glfw_SOURCES ${common_SOURCES} wgl_context.c)
+elseif (_GLFW_X11)
+    list(APPEND glfw_HEADERS ${common_HEADERS} glx_platform.h)
+    list(APPEND glfw_SOURCES ${common_SOURCES} glx_context.c)
+endif()
+
+if (_GLFW_NSGL)
+    # For some reason, CMake doesn't know about .m
+    set_source_files_properties(${glfw_SOURCES} PROPERTIES LANGUAGE C)
+endif()
+
 add_library(glfw ${glfw_SOURCES} ${glfw_HEADERS})
 set_target_properties(glfw PROPERTIES OUTPUT_NAME "${GLFW_LIB_NAME}")
 
@@ -52,7 +68,7 @@ if (BUILD_SHARED_LIBS)
         set_target_properties(glfw PROPERTIES SOVERSION ${GLFW_VERSION_MAJOR})
     endif()
 
-    if (_GLFW_WIN32_WGL)
+    if (_GLFW_WIN32)
         # The GLFW DLL needs a special compile-time macro and import library name
         set_target_properties(glfw PROPERTIES PREFIX "" IMPORT_PREFIX "")
 
@@ -61,8 +77,9 @@ if (BUILD_SHARED_LIBS)
         else()
             set_target_properties(glfw PROPERTIES IMPORT_SUFFIX "dll.lib")
         endif()
-    elseif (_GLFW_COCOA_NSGL)
-        # Append -fno-common to the compile flags to work around a bug in the Apple GCC
+    elseif (_GLFW_COCOA)
+        # Append -fno-common to the compile flags to work around a bug in
+        # Apple's GCC
         get_target_property(glfw_CFLAGS glfw COMPILE_FLAGS)
         if (NOT glfw_CFLAGS)
             set(glfw_CFLAGS "")

src/cocoa_platform.h

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Cocoa/NSOpenGL
+// Platform:    Cocoa
 // API Version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@@ -27,13 +27,12 @@
 //
 //========================================================================
 
-#ifndef _platform_h_
-#define _platform_h_
+#ifndef _cocoa_platform_h_
+#define _cocoa_platform_h_
 
 
 #include <stdint.h>
 
-
 #if defined(__OBJC__)
 #import <Cocoa/Cocoa.h>
 #else
@@ -41,11 +40,14 @@
 typedef void* id;
 #endif
 
+#if defined(_GLFW_NSGL)
+ #include "nsgl_platform.h"
+#else
+ #error "No supported context creation API selected"
+#endif
 
-#define _GLFW_PLATFORM_WINDOW_STATE  _GLFWwindowNS NS
-#define _GLFW_PLATFORM_CONTEXT_STATE _GLFWcontextNSGL NSGL
+#define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowNS  NS
 #define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryNS NS
-#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryNSGL NSGL
 
 
 //========================================================================
@@ -58,16 +60,6 @@ typedef void* id;
 typedef intptr_t GLFWintptr;
 
 
-//------------------------------------------------------------------------
-// Platform-specific OpenGL context structure
-//------------------------------------------------------------------------
-typedef struct _GLFWcontextNSGL
-{
-    id           pixelFormat;
-    id	         context;
-} _GLFWcontextNSGL;
-
-
 //------------------------------------------------------------------------
 // Platform-specific window structure
 //------------------------------------------------------------------------
@@ -99,16 +91,6 @@ typedef struct _GLFWlibraryNS
 } _GLFWlibraryNS;
 
 
-//------------------------------------------------------------------------
-// Platform-specific library global data for NSGL
-//------------------------------------------------------------------------
-typedef struct _GLFWlibraryNSGL
-{
-    // dlopen handle for dynamically loading OpenGL extension entry points
-    void*            framework;
-} _GLFWlibraryNSGL;
-
-
 //========================================================================
 // Prototypes for platform specific internal functions
 //========================================================================
@@ -128,4 +110,4 @@ void _glfwRestoreVideoMode(void);
 int _glfwInitOpenGL(void);
 void _glfwTerminateOpenGL(void);
 
-#endif // _platform_h_
+#endif // _cocoa_platform_h_

src/config.h.in

@@ -35,12 +35,21 @@
 // it.  Instead, you should modify the config.h.in file.
 //========================================================================
 
-// Define this to 1 if building GLFW for X11/GLX
-#cmakedefine _GLFW_X11_GLX
-// Define this to 1 if building GLFW for Win32/WGL
-#cmakedefine _GLFW_WIN32_WGL
-// Define this to 1 if building GLFW for Cocoa/NSOpenGL
-#cmakedefine _GLFW_COCOA_NSGL
+// Define this to 1 if building GLFW for X11
+#cmakedefine _GLFW_X11
+// Define this to 1 if building GLFW for Win32
+#cmakedefine _GLFW_WIN32
+// Define this to 1 if building GLFW for Cocoa
+#cmakedefine _GLFW_COCOA
+
+// Define this to 1 if building GLFW for EGL
+#cmakedefine _GLFW_EGL
+// Define this to 1 if building GLFW for GLX
+#cmakedefine _GLFW_GLX
+// Define this to 1 if building GLFW for WGL
+#cmakedefine _GLFW_WGL
+// Define this to 1 if building GLFW for NSGL
+#cmakedefine _GLFW_NSGL
 
 // Define this to 1 if building as a shared library / dynamic library / DLL
 #cmakedefine _GLFW_BUILD_DLL
@@ -63,6 +72,9 @@
 // Define this to 1 if glXGetProcAddressEXT is available
 #cmakedefine _GLFW_HAS_GLXGETPROCADDRESSEXT
 
+// Define this to 1 if eglGetProcAddress is available
+#cmakedefine _GLFW_HAS_EGLGETPROCADDRESS
+
 // The GLFW version as used by glfwGetVersionString
 #define _GLFW_VERSION_FULL "@GLFW_VERSION_FULL@"
 

src/opengl.c → src/context.c

@@ -33,6 +33,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <limits.h>
+#include <stdio.h>
 
 
 //========================================================================
@@ -253,8 +254,8 @@ const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
 
 
 //========================================================================
-// Checks whether the OpenGL part of the window config is sane
-// It blames glfwCreateWindow because that's the only caller
+// Checks whether the client API part of the window config is sane
+// It blames glfwOpenWindow because that's the only caller
 //========================================================================
 
 GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
@@ -488,7 +489,7 @@ GLboolean _glfwIsValidContext(_GLFWwndconfig* wndconfig)
 
 
 //========================================================================
-// Check if a string can be found in an OpenGL extension string
+// Check if a string can be found in a client API extension string
 //========================================================================
 
 int _glfwStringInExtensionString(const char* string,
@@ -527,7 +528,7 @@ int _glfwStringInExtensionString(const char* string,
 //////////////////////////////////////////////////////////////////////////
 
 //========================================================================
-// Make the OpenGL context associated with the specified window current
+// Make the context associated with the specified window current
 //========================================================================
 
 GLFWAPI void glfwMakeContextCurrent(GLFWwindow handle)
@@ -548,7 +549,7 @@ GLFWAPI void glfwMakeContextCurrent(GLFWwindow handle)
 
 
 //========================================================================
-// Return the window object whose context is current
+// Returns the window whose context is current
 //========================================================================
 
 GLFWAPI GLFWwindow glfwGetCurrentContext(void)
@@ -604,7 +605,7 @@ GLFWAPI void glfwSwapInterval(int interval)
 
 
 //========================================================================
-// Check if an OpenGL extension is available at runtime
+// Check if a client API extension is available at runtime
 //========================================================================
 
 GLFWAPI int glfwExtensionSupported(const char* extension)
@@ -667,8 +668,8 @@ GLFWAPI int glfwExtensionSupported(const char* extension)
 
 
 //========================================================================
-// Get the function pointer to an OpenGL function.
-// This function can be used to get access to extended OpenGL functions.
+// Get the function pointer to a client API function
+// This can be used to get access to client API extension functions
 //========================================================================
 
 GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)

src/egl_context.c

@@ -0,0 +1,595 @@
+//========================================================================
+// GLFW - An OpenGL library
+// Platform:    EGL
+// API version: 3.0
+// WWW:         http://www.glfw.org/
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <[email protected]>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+//========================================================================
+// Thread local storage attribute macro
+//========================================================================
+#if defined(_MSC_VER)
+ #define _GLFW_TLS __declspec(thread)
+#elif defined(__GNUC__)
+ #define _GLFW_TLS __thread
+#else
+ #define _GLFW_TLS
+#endif
+
+
+//========================================================================
+// The per-thread current context/window pointer
+//========================================================================
+static _GLFW_TLS _GLFWwindow* _glfwCurrentWindow = NULL;
+
+
+//========================================================================
+// Returns the specified attribute of the specified EGLConfig
+//========================================================================
+
+static int getConfigAttrib(EGLConfig config, int attrib)
+{
+    int value;
+    eglGetConfigAttrib(_glfwLibrary.EGL.display, config, attrib, &value);
+    return value;
+}
+
+
+//========================================================================
+// Return a list of available and usable framebuffer configs
+//========================================================================
+
+static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window,
+                                   const _GLFWwndconfig* wndconfig,
+                                   unsigned int* found)
+{
+    EGLConfig* configs;
+    _GLFWfbconfig* result;
+    int i, count = 0;
+
+    *found = 0;
+
+    eglGetConfigs(_glfwLibrary.EGL.display, NULL, 0, &count);
+
+    configs = (EGLConfig*) malloc(sizeof(EGLConfig) * count);
+    if (!configs)
+    {
+        _glfwSetError(GLFW_OUT_OF_MEMORY, NULL);
+        return NULL;
+    }
+
+    eglGetConfigs(_glfwLibrary.EGL.display, configs, count, &count);
+    if (!count)
+    {
+        free(configs);
+
+        _glfwSetError(GLFW_API_UNAVAILABLE,
+                      "EGL: No EGLConfigs returned");
+        return NULL;
+    }
+
+    result = (_GLFWfbconfig*) malloc(sizeof(_GLFWfbconfig) * count);
+    if (!result)
+    {
+        free(configs);
+
+        _glfwSetError(GLFW_OUT_OF_MEMORY, NULL);
+        return NULL;
+    }
+
+    for (i = 0;  i < count;  i++)
+    {
+        _GLFWfbconfig* f = result + *found;
+
+        if (!getConfigAttrib(configs[i], EGL_NATIVE_VISUAL_ID))
+        {
+            // Only consider EGLConfigs with associated visuals
+            continue;
+        }
+
+        if (!(getConfigAttrib(configs[i], EGL_COLOR_BUFFER_TYPE) & EGL_RGB_BUFFER))
+        {
+            // Only consider RGB(A) EGLConfigs
+            continue;
+        }
+
+        if (!(getConfigAttrib(configs[i], EGL_SURFACE_TYPE) & EGL_WINDOW_BIT))
+        {
+            // Only consider window EGLConfigs
+            continue;
+        }
+
+        if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
+        {
+            if (wndconfig->glMajor == 1)
+            {
+                if (!(getConfigAttrib(configs[i], EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES_BIT))
+                    continue;
+            }
+            else
+            {
+                if (!(getConfigAttrib(configs[i], EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES2_BIT))
+                    continue;
+            }
+        }
+        else if (wndconfig->clientAPI == GLFW_OPENGL_API)
+        {
+            if (!(getConfigAttrib(configs[i], EGL_RENDERABLE_TYPE) & EGL_OPENGL_BIT))
+                continue;
+        }
+
+        f->redBits = getConfigAttrib(configs[i], EGL_RED_SIZE);
+        f->greenBits = getConfigAttrib(configs[i], EGL_GREEN_SIZE);
+        f->blueBits = getConfigAttrib(configs[i], EGL_BLUE_SIZE);
+
+        f->alphaBits = getConfigAttrib(configs[i], EGL_ALPHA_SIZE);
+        f->depthBits = getConfigAttrib(configs[i], EGL_DEPTH_SIZE);
+        f->stencilBits = getConfigAttrib(configs[i], EGL_STENCIL_SIZE);
+
+        f->samples = getConfigAttrib(configs[i], EGL_SAMPLES);
+
+        // NOTE: There does not appear to be any way to request sRGB
+        // framebuffers for OpenGL or GLES contexts; only for OpenVG ones
+        f->sRGB = GL_FALSE;
+
+        f->platformID = (GLFWintptr) getConfigAttrib(configs[i], EGL_CONFIG_ID);
+
+        (*found)++;
+    }
+
+    free(configs);
+    return result;
+}
+
+
+//========================================================================
+// Create the actual OpenGL(|ES) context
+//========================================================================
+
+#define setEGLattrib(attribs, index, attribName, attribValue) \
+{ \
+    attribs[index++] = attribName; \
+    attribs[index++] = attribValue; \
+}
+
+static int createContext(_GLFWwindow* window,
+                         const _GLFWwndconfig* wndconfig,
+                         EGLint fbconfigID)
+{
+    int attribs[40];
+    EGLint count, index;
+    EGLConfig config;
+    EGLContext share = NULL;
+
+    if (wndconfig->share)
+        share = wndconfig->share->EGL.context;
+
+    // Retrieve the previously selected EGLConfig
+    {
+        index = 0;
+
+        setEGLattrib(attribs, index, EGL_CONFIG_ID, fbconfigID);
+        setEGLattrib(attribs, index, EGL_NONE, EGL_NONE);
+
+        eglChooseConfig(_glfwLibrary.EGL.display, attribs, &config, 1, &count);
+        if (!count)
+        {
+            _glfwSetError(GLFW_PLATFORM_ERROR,
+                          "EGL: Failed to retrieve the selected EGLConfig");
+            return GL_FALSE;
+        }
+    }
+
+    // Retrieve the corresponding visual
+    // NOTE: This is the only non-portable code in this file.
+    // Maybe it would not hurt too much to add #ifdefs for different platforms?
+#if defined(_GLFW_X11)
+    {
+        int mask;
+        EGLint redBits, greenBits, blueBits, alphaBits, visualID = 0;
+        XVisualInfo info;
+
+        eglGetConfigAttrib(_glfwLibrary.EGL.display, config,
+                           EGL_NATIVE_VISUAL_ID, &visualID);
+
+        info.screen = _glfwLibrary.X11.screen;
+        mask = VisualScreenMask;
+
+        if (visualID)
+        {
+            // The X window visual must match the EGL config
+            info.visualid = visualID;
+            mask |= VisualIDMask;
+        }
+        else
+        {
+            // some EGL drivers don't implement the EGL_NATIVE_VISUAL_ID
+            // attribute, so attempt to find the closest match.
+
+            eglGetConfigAttrib(_glfwLibrary.EGL.display, config,
+                               EGL_RED_SIZE, &redBits);
+            eglGetConfigAttrib(_glfwLibrary.EGL.display, config,
+                               EGL_GREEN_SIZE, &greenBits);
+            eglGetConfigAttrib(_glfwLibrary.EGL.display, config,
+                               EGL_BLUE_SIZE, &blueBits);
+            eglGetConfigAttrib(_glfwLibrary.EGL.display, config,
+                               EGL_ALPHA_SIZE, &alphaBits);
+
+            info.depth = redBits + greenBits + blueBits + alphaBits;
+            mask |= VisualDepthMask;
+        }
+
+        window->EGL.visual = XGetVisualInfo(_glfwLibrary.X11.display,
+                                            mask, &info, &count);
+
+        if (window->EGL.visual == NULL)
+        {
+            _glfwSetError(GLFW_PLATFORM_ERROR,
+                          "EGL: Failed to retrieve visual for EGLConfig");
+            return GL_FALSE;
+        }
+    }
+#endif
+
+    if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
+    {
+        if (!eglBindAPI(EGL_OPENGL_ES_API))
+        {
+            _glfwSetError(GLFW_PLATFORM_ERROR,
+                          "EGL: OpenGL ES is not supported");
+            return GL_FALSE;
+        }
+    }
+    else
+    {
+        if (!eglBindAPI(EGL_OPENGL_API))
+        {
+            _glfwSetError(GLFW_PLATFORM_ERROR,
+                          "EGL: OpenGL is not supported");
+            return GL_FALSE;
+        }
+    }
+
+    index = 0;
+
+    if (_glfwLibrary.EGL.KHR_create_context)
+    {
+        setEGLattrib(attribs, index, EGL_CONTEXT_MAJOR_VERSION_KHR, wndconfig->glMajor);
+        setEGLattrib(attribs, index, EGL_CONTEXT_MINOR_VERSION_KHR, wndconfig->glMinor);
+
+        if (wndconfig->glForward || wndconfig->glDebug || wndconfig->glRobustness)
+        {
+            int flags = 0;
+
+            if (wndconfig->glForward)
+                flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
+
+            if (wndconfig->glDebug)
+                flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
+
+            if (wndconfig->glRobustness)
+                flags |= EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR;
+
+            setEGLattrib(attribs, index, EGL_CONTEXT_FLAGS_KHR, flags);
+        }
+
+        if (wndconfig->glProfile)
+        {
+            int flags = 0;
+
+            if (wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE)
+                flags = EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
+            else if (wndconfig->glProfile == GLFW_OPENGL_COMPAT_PROFILE)
+                flags = EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR;
+
+            setEGLattrib(attribs, index, EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR, flags);
+        }
+
+        if (wndconfig->glRobustness)
+        {
+            int strategy;
+
+            if (wndconfig->glRobustness == GLFW_OPENGL_NO_RESET_NOTIFICATION)
+                strategy = EGL_NO_RESET_NOTIFICATION_KHR;
+            else if (wndconfig->glRobustness == GLFW_OPENGL_LOSE_CONTEXT_ON_RESET)
+                strategy = EGL_LOSE_CONTEXT_ON_RESET_KHR;
+
+            setEGLattrib(attribs, index, EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR, strategy);
+        }
+    }
+    else
+    {
+        if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
+            setEGLattrib(attribs, index, EGL_CONTEXT_CLIENT_VERSION, wndconfig->glMajor);
+    }
+
+    setEGLattrib(attribs, index, EGL_NONE, EGL_NONE);
+
+    window->EGL.context = eglCreateContext(_glfwLibrary.EGL.display,
+                                           config, share, attribs);
+
+    if (window->EGL.context == EGL_NO_CONTEXT)
+    {
+        // TODO: Handle all the various error codes here
+
+        _glfwSetError(GLFW_PLATFORM_ERROR,
+                      "EGL: Failed to create context");
+        return GL_FALSE;
+    }
+
+    window->EGL.config = config;
+
+    return GL_TRUE;
+}
+
+#undef setEGLattrib
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+//========================================================================
+// Initialize EGL
+//========================================================================
+
+int _glfwInitOpenGL(void)
+{
+#ifdef _GLFW_DLOPEN_LIBEGL
+    int i;
+    char* libEGL_names[ ] =
+    {
+        "libEGL.so",
+        "libEGL.so.1",
+        "/usr/lib/libEGL.so",
+        "/usr/lib/libEGL.so.1",
+        NULL
+    };
+
+    for (i = 0;  libEGL_names[i] != NULL;  i++)
+    {
+        _glfwLibrary.EGL.libEGL = dlopen(libEGL_names[i], RTLD_LAZY | RTLD_GLOBAL);
+        if (_glfwLibrary.EGL.libEGL)
+            break;
+    }
+
+    if (!_glfwLibrary.EGL.libEGL)
+    {
+        _glfwSetError(GLFW_PLATFORM_ERROR, "EGL: Failed to find libEGL");
+        return GL_FALSE;
+    }
+#endif
+
+    _glfwLibrary.EGL.display = eglGetDisplay(_GLFW_EGL_NATIVE_DISPLAY);
+    if (_glfwLibrary.EGL.display == EGL_NO_DISPLAY)
+    {
+        _glfwSetError(GLFW_API_UNAVAILABLE,
+                      "EGL: Failed to get EGL display");
+        return GL_FALSE;
+    }
+
+    if (!eglInitialize(_glfwLibrary.EGL.display,
+                       &_glfwLibrary.EGL.majorVersion,
+                       &_glfwLibrary.EGL.minorVersion))
+    {
+        _glfwSetError(GLFW_API_UNAVAILABLE,
+                      "EGL: Failed to initialize EGL");
+        return GL_FALSE;
+    }
+
+    if (_glfwPlatformExtensionSupported("EGL_KHR_create_context"))
+        _glfwLibrary.EGL.KHR_create_context = GL_TRUE;
+
+    return GL_TRUE;
+}
+
+
+//========================================================================
+// Terminate EGL
+//========================================================================
+
+void _glfwTerminateOpenGL(void)
+{
+#ifdef _GLFW_DLOPEN_LIBEGL
+    if (_glfwLibrary.EGL.libEGL != NULL)
+    {
+        dlclose(_glfwLibrary.EGL.libEGL);
+        _glfwLibrary.EGL.libEGL = NULL;
+    }
+#endif
+
+    eglTerminate(_glfwLibrary.EGL.display);
+}
+
+
+//========================================================================
+// Prepare for creation of the OpenGL context
+//========================================================================
+
+int _glfwCreateContext(_GLFWwindow* window,
+                       const _GLFWwndconfig* wndconfig,
+                       const _GLFWfbconfig* fbconfig)
+{
+    _GLFWfbconfig closest;
+
+    // Choose the best available fbconfig
+    {
+        unsigned int fbcount;
+        _GLFWfbconfig* fbconfigs;
+        const _GLFWfbconfig* result;
+
+        fbconfigs = getFBConfigs(window, wndconfig, &fbcount);
+        if (!fbconfigs)
+        {
+            _glfwSetError(GLFW_PLATFORM_ERROR,
+                          "EGL: No usable EGLFBConfigs found");
+            return GL_FALSE;
+        }
+
+        result = _glfwChooseFBConfig(fbconfig, fbconfigs, fbcount);
+        if (!result)
+        {
+            _glfwSetError(GLFW_PLATFORM_ERROR,
+                          "EGL: No EGLFBConfig matched the criteria");
+
+            free(fbconfigs);
+            return GL_FALSE;
+        }
+
+        closest = *result;
+        free(fbconfigs);
+    }
+
+    return createContext(window, wndconfig, closest.platformID);
+}
+
+
+//========================================================================
+// Destroy the OpenGL context
+//========================================================================
+
+void _glfwDestroyContext(_GLFWwindow* window)
+{
+    if (window->EGL.visual)
+    {
+       XFree(window->EGL.visual);
+       window->EGL.visual = NULL;
+    }
+
+    if (window->EGL.surface)
+    {
+        eglDestroySurface(_glfwLibrary.EGL.display, window->EGL.surface);
+        window->EGL.surface = EGL_NO_SURFACE;
+    }
+
+    if (window->EGL.context)
+    {
+        eglDestroyContext(_glfwLibrary.EGL.display, window->EGL.context);
+        window->EGL.context = EGL_NO_CONTEXT;
+    }
+}
+
+
+//========================================================================
+// Make the OpenGL context associated with the specified window current
+//========================================================================
+
+void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
+{
+    if (window)
+    {
+        if (window->EGL.surface == EGL_NO_SURFACE)
+        {
+            window->EGL.surface = eglCreateWindowSurface(_glfwLibrary.EGL.display,
+                                                         window->EGL.config,
+                                                         _GLFW_EGL_NATIVE_WINDOW,
+                                                         NULL);
+            if (window->EGL.surface == EGL_NO_SURFACE)
+            {
+                _glfwSetError(GLFW_PLATFORM_ERROR,
+                              "EGL: Failed to create window surface");
+            }
+        }
+
+        eglMakeCurrent(_glfwLibrary.EGL.display,
+                       window->EGL.surface,
+                       window->EGL.surface,
+                       window->EGL.context);
+    }
+    else
+    {
+        eglMakeCurrent(_glfwLibrary.EGL.display,
+                       EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    }
+
+    _glfwCurrentWindow = window;
+}
+
+
+//========================================================================
+// Return the window object whose context is current
+//========================================================================
+
+_GLFWwindow* _glfwPlatformGetCurrentContext(void)
+{
+    return _glfwCurrentWindow;
+}
+
+
+//========================================================================
+// Swap OpenGL buffers
+//========================================================================
+
+void _glfwPlatformSwapBuffers(_GLFWwindow* window)
+{
+    eglSwapBuffers(_glfwLibrary.EGL.display, window->EGL.surface);
+}
+
+
+//========================================================================
+// Set double buffering swap interval
+//========================================================================
+
+void _glfwPlatformSwapInterval(int interval)
+{
+    eglSwapInterval(_glfwLibrary.EGL.display, interval);
+}
+
+
+//========================================================================
+// Check if an OpenGL extension is available at runtime
+//========================================================================
+
+int _glfwPlatformExtensionSupported(const char* extension)
+{
+    const char* extensions;
+
+    extensions = eglQueryString(_glfwLibrary.EGL.display, EGL_EXTENSIONS);
+    if (extensions != NULL)
+    {
+        if (_glfwStringInExtensionString(extension, (unsigned char*) extensions))
+            return GL_TRUE;
+    }
+
+    return GL_FALSE;
+}
+
+
+//========================================================================
+// Get the function pointer to an OpenGL function
+//========================================================================
+
+GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
+{
+    return _glfw_eglGetProcAddress(procname);
+}
+

src/egl_platform.h

@@ -0,0 +1,96 @@
+//========================================================================
+// GLFW - An OpenGL library
+// Platform:    EGL
+// API version: 3.0
+// WWW:         http://www.glfw.org/
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <[email protected]>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#ifndef _egl_platform_h_
+#define _egl_platform_h_
+
+#include <EGL/egl.h>
+
+// This path may need to be changed if you build GLFW using your own setup
+// We ship and use our own copy of eglext.h since GLFW uses fairly new
+// extensions and not all operating systems come with an up-to-date version
+#include "../support/GL/eglext.h"
+
+// Do we have support for dlopen/dlsym?
+#if defined(_GLFW_HAS_DLOPEN)
+ #include <dlfcn.h>
+#endif
+
+// We support two different ways for getting addresses for EGL
+// extension functions: eglGetProcAddress and dlsym
+#if defined(_GLFW_HAS_EGLGETPROCADDRESS)
+ #define _glfw_eglGetProcAddress(x) eglGetProcAddress(x)
+#elif defined(_GLFW_HAS_DLOPEN)
+ #define _glfw_eglGetProcAddress(x) dlsym(_glfwLibrary.EGL.libEGL, x)
+ #define _GLFW_DLOPEN_LIBEGL
+#else
+ #error "No OpenGL entry point retrieval mechanism was enabled"
+#endif
+
+#define _GLFW_PLATFORM_CONTEXT_STATE        _GLFWcontextEGL EGL
+#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryEGL EGL
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+//------------------------------------------------------------------------
+// Platform-specific OpenGL context structure
+//------------------------------------------------------------------------
+typedef struct _GLFWcontextEGL
+{
+   EGLConfig      config;
+   EGLContext     context;
+   EGLSurface     surface;
+
+#if defined(_GLFW_X11)
+   XVisualInfo*   visual;
+#endif
+} _GLFWcontextEGL;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for EGL
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryEGL
+{
+    EGLDisplay      display;
+    EGLint          majorVersion, minorVersion;
+
+    GLboolean       KHR_create_context;
+
+#if defined(_GLFW_DLOPEN_LIBEGL)
+    void*           libEGL;  // dlopen handle for libEGL.so
+#endif
+} _GLFWlibraryEGL;
+
+
+#endif // _egl_platform_h_

src/x11_opengl.c → src/glx_context.c

@@ -632,16 +632,6 @@ void _glfwDestroyContext(_GLFWwindow* window)
 }
 
 
-//========================================================================
-// Return the X visual associated with the specified context
-//========================================================================
-
-XVisualInfo* _glfwGetContextVisual(_GLFWwindow* window)
-{
-    return window->GLX.visual;
-}
-
-
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////

src/glx_platform.h

@@ -0,0 +1,120 @@
+//========================================================================
+// GLFW - An OpenGL library
+// Platform:    X11/GLX
+// API version: 3.0
+// WWW:         http://www.glfw.org/
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <[email protected]>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#ifndef _x11_glx_platform_h_
+#define _x11_glx_platform_h_
+
+#define GLX_GLXEXT_LEGACY
+#include <GL/glx.h>
+
+// This path may need to be changed if you build GLFW using your own setup
+// We ship and use our own copy of glxext.h since GLFW uses fairly new
+// extensions and not all operating systems come with an up-to-date version
+#include "../support/GL/glxext.h"
+
+// Do we have support for dlopen/dlsym?
+#if defined(_GLFW_HAS_DLOPEN)
+ #include <dlfcn.h>
+#endif
+
+// We support four different ways for getting addresses for GL/GLX
+// extension functions: glXGetProcAddress, glXGetProcAddressARB,
+// glXGetProcAddressEXT, and dlsym
+#if defined(_GLFW_HAS_GLXGETPROCADDRESSARB)
+ #define _glfw_glXGetProcAddress(x) glXGetProcAddressARB(x)
+#elif defined(_GLFW_HAS_GLXGETPROCADDRESS)
+ #define _glfw_glXGetProcAddress(x) glXGetProcAddress(x)
+#elif defined(_GLFW_HAS_GLXGETPROCADDRESSEXT)
+ #define _glfw_glXGetProcAddress(x) glXGetProcAddressEXT(x)
+#elif defined(_GLFW_HAS_DLOPEN)
+ #define _glfw_glXGetProcAddress(x) dlsym(_glfwLibrary.GLX.libGL, x)
+ #define _GLFW_DLOPEN_LIBGL
+#else
+ #error "No OpenGL entry point retrieval mechanism was enabled"
+#endif
+
+#define _GLFW_PLATFORM_CONTEXT_STATE        _GLFWcontextGLX GLX
+#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryGLX GLX
+
+#ifndef GLX_MESA_swap_control
+typedef int (*PFNGLXSWAPINTERVALMESAPROC)(int);
+#endif
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+//------------------------------------------------------------------------
+// Platform-specific OpenGL context structure
+//------------------------------------------------------------------------
+typedef struct _GLFWcontextGLX
+{
+    GLXContext    context;           // OpenGL rendering context
+    XVisualInfo*  visual;            // Visual for selected GLXFBConfig
+
+} _GLFWcontextGLX;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for GLX
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryGLX
+{
+    // Server-side GLX version
+    int             majorVersion, minorVersion;
+
+    // GLX extensions
+    PFNGLXSWAPINTERVALSGIPROC             SwapIntervalSGI;
+    PFNGLXSWAPINTERVALEXTPROC             SwapIntervalEXT;
+    PFNGLXSWAPINTERVALMESAPROC            SwapIntervalMESA;
+    PFNGLXGETFBCONFIGATTRIBSGIXPROC       GetFBConfigAttribSGIX;
+    PFNGLXCHOOSEFBCONFIGSGIXPROC          ChooseFBConfigSGIX;
+    PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC CreateContextWithConfigSGIX;
+    PFNGLXGETVISUALFROMFBCONFIGSGIXPROC   GetVisualFromFBConfigSGIX;
+    PFNGLXCREATECONTEXTATTRIBSARBPROC     CreateContextAttribsARB;
+    GLboolean   SGIX_fbconfig;
+    GLboolean   SGI_swap_control;
+    GLboolean   EXT_swap_control;
+    GLboolean   MESA_swap_control;
+    GLboolean   ARB_multisample;
+    GLboolean   ARB_framebuffer_sRGB;
+    GLboolean   ARB_create_context;
+    GLboolean   ARB_create_context_profile;
+    GLboolean   ARB_create_context_robustness;
+    GLboolean   EXT_create_context_es2_profile;
+
+#if defined(_GLFW_DLOPEN_LIBGL)
+    void*           libGL;  // dlopen handle for libGL.so
+#endif
+} _GLFWlibraryGLX;
+
+
+#endif // _x11_glx_platform_h_

src/internal.h

@@ -65,14 +65,14 @@ typedef struct _GLFWlibrary     _GLFWlibrary;
 // extensions and not all operating systems come with an up-to-date version
 #include "../support/GL/glext.h"
 
-#if defined(_GLFW_COCOA_NSGL)
+#if defined(_GLFW_COCOA)
  #include "cocoa_platform.h"
-#elif defined(_GLFW_WIN32_WGL)
+#elif defined(_GLFW_WIN32)
  #include "win32_platform.h"
-#elif defined(_GLFW_X11_GLX)
+#elif defined(_GLFW_X11)
  #include "x11_platform.h"
 #else
- #error "No supported platform selected"
+ #error "No supported window creation API selected"
 #endif
 
 

src/nsgl_platform.h

@@ -0,0 +1,62 @@
+//========================================================================
+// GLFW - An OpenGL library
+// Platform:    NSOpenGL
+// API Version: 3.0
+// WWW:         http://www.glfw.org/
+//------------------------------------------------------------------------
+// Copyright (c) 2009-2010 Camilla Berglund <[email protected]>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#ifndef _nsgl_platform_h_
+#define _nsgl_platform_h_
+
+
+#define _GLFW_PLATFORM_CONTEXT_STATE        _GLFWcontextNSGL NSGL
+#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryNSGL NSGL
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+//------------------------------------------------------------------------
+// Platform-specific OpenGL context structure
+//------------------------------------------------------------------------
+typedef struct _GLFWcontextNSGL
+{
+    id           pixelFormat;
+    id	         context;
+} _GLFWcontextNSGL;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for NSGL
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryNSGL
+{
+    // dlopen handle for dynamically loading OpenGL extension entry points
+    void*            framework;
+} _GLFWlibraryNSGL;
+
+
+#endif // _nsgl_platform_h_

src/wgl_platform.h

@@ -0,0 +1,84 @@
+//========================================================================
+// GLFW - An OpenGL library
+// Platform:    WGL
+// API version: 3.0
+// WWW:         http://www.glfw.org/
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <[email protected]>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#ifndef _wgl_platform_h_
+#define _wgl_platform_h_
+
+// This path may need to be changed if you build GLFW using your own setup
+// We ship and use our own copy of wglext.h since GLFW uses fairly new
+// extensions and not all operating systems come with an up-to-date version
+#include "../support/GL/wglext.h"
+
+
+#define _GLFW_PLATFORM_CONTEXT_STATE        _GLFWcontextWGL WGL
+#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryWGL WGL
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+//------------------------------------------------------------------------
+// Platform-specific OpenGL context structure
+//------------------------------------------------------------------------
+typedef struct _GLFWcontextWGL
+{
+    // Platform specific window resources
+    HDC       DC;              // Private GDI device context
+    HGLRC     context;         // Permanent rendering context
+
+    // Platform specific extensions (context specific)
+    PFNWGLSWAPINTERVALEXTPROC           SwapIntervalEXT;
+    PFNWGLGETPIXELFORMATATTRIBIVARBPROC GetPixelFormatAttribivARB;
+    PFNWGLGETEXTENSIONSSTRINGEXTPROC    GetExtensionsStringEXT;
+    PFNWGLGETEXTENSIONSSTRINGARBPROC    GetExtensionsStringARB;
+    PFNWGLCREATECONTEXTATTRIBSARBPROC   CreateContextAttribsARB;
+    GLboolean                           EXT_swap_control;
+    GLboolean                           ARB_multisample;
+    GLboolean                           ARB_framebuffer_sRGB;
+    GLboolean                           ARB_pixel_format;
+    GLboolean                           ARB_create_context;
+    GLboolean                           ARB_create_context_profile;
+    GLboolean                           EXT_create_context_es2_profile;
+    GLboolean                           ARB_create_context_robustness;
+} _GLFWcontextWGL;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for WGL
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryWGL
+{
+    int dummy;
+
+} _GLFWlibraryWGL;
+
+
+#endif // _wgl_platform_h_

src/win32_init.c

@@ -232,6 +232,11 @@ int _glfwPlatformTerminate(void)
 const char* _glfwPlatformGetVersionString(void)
 {
     const char* version = _GLFW_VERSION_FULL
+#if defined(_GLFW_WGL)
+        " WGL"
+#elif defined(_GLFW_EGL)
+        " EGL"
+#endif
 #if defined(__MINGW32__)
         " MinGW"
 #elif defined(_MSC_VER)

src/win32_platform.h

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Win32/WGL
+// Platform:    Win32
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@@ -28,8 +28,8 @@
 //
 //========================================================================
 
-#ifndef _platform_h_
-#define _platform_h_
+#ifndef _win32_platform_h_
+#define _win32_platform_h_
 
 
 // We don't need all the fancy stuff
@@ -63,11 +63,6 @@
 #include <windows.h>
 #include <mmsystem.h>
 
-// This path may need to be changed if you build GLFW using your own setup
-// We ship and use our own copy of wglext.h since GLFW uses fairly new
-// extensions and not all operating systems come with an up-to-date version
-#include "../support/GL/wglext.h"
-
 
 //========================================================================
 // Hack: Define things that some windows.h variants don't
@@ -110,10 +105,18 @@ typedef DWORD (WINAPI * TIMEGETTIME_T) (void);
 #define _GLFW_WNDCLASSNAME L"GLFW30"
 
 
-#define _GLFW_PLATFORM_WINDOW_STATE  _GLFWwindowWin32 Win32
-#define _GLFW_PLATFORM_CONTEXT_STATE _GLFWcontextWGL WGL
+#if defined(_GLFW_WGL)
+ #include "wgl_platform.h"
+#elif defined(_GLFW_EGL)
+ #define _GLFW_EGL_NATIVE_WINDOW  window->Win32.handle
+ #define _GLFW_EGL_NATIVE_DISPLAY NULL
+ #include "egl_platform.h"
+#else
+ #error "No supported context creation API selected"
+#endif
+
+#define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowWin32  Win32
 #define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryWin32 Win32
-#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryWGL WGL
 
 
 //========================================================================
@@ -126,32 +129,6 @@ typedef DWORD (WINAPI * TIMEGETTIME_T) (void);
 typedef INT_PTR GLFWintptr;
 
 
-//------------------------------------------------------------------------
-// Platform-specific OpenGL context structure
-//------------------------------------------------------------------------
-typedef struct _GLFWcontextWGL
-{
-    // Platform specific window resources
-    HDC       DC;              // Private GDI device context
-    HGLRC     context;         // Permanent rendering context
-
-    // Platform specific extensions (context specific)
-    PFNWGLSWAPINTERVALEXTPROC           SwapIntervalEXT;
-    PFNWGLGETPIXELFORMATATTRIBIVARBPROC GetPixelFormatAttribivARB;
-    PFNWGLGETEXTENSIONSSTRINGEXTPROC    GetExtensionsStringEXT;
-    PFNWGLGETEXTENSIONSSTRINGARBPROC    GetExtensionsStringARB;
-    PFNWGLCREATECONTEXTATTRIBSARBPROC   CreateContextAttribsARB;
-    GLboolean                           EXT_swap_control;
-    GLboolean                           ARB_multisample;
-    GLboolean                           ARB_pixel_format;
-    GLboolean                           ARB_framebuffer_sRGB;
-    GLboolean                           ARB_create_context;
-    GLboolean                           ARB_create_context_profile;
-    GLboolean                           EXT_create_context_es2_profile;
-    GLboolean                           ARB_create_context_robustness;
-} _GLFWcontextWGL;
-
-
 //------------------------------------------------------------------------
 // Platform-specific window structure
 //------------------------------------------------------------------------
@@ -213,16 +190,6 @@ typedef struct _GLFWlibraryWin32
 } _GLFWlibraryWin32;
 
 
-//------------------------------------------------------------------------
-// Platform-specific library global data for WGL
-//------------------------------------------------------------------------
-typedef struct _GLFWlibraryWGL
-{
-    int dummy;
-
-} _GLFWlibraryWGL;
-
-
 //========================================================================
 // Prototypes for platform specific internal functions
 //========================================================================
@@ -247,4 +214,4 @@ void _glfwSetVideoMode(int* width, int* height,
 void _glfwRestoreVideoMode(void);
 
 
-#endif // _platform_h_
+#endif // _win32_platform_h_

src/x11_fullscreen.c

@@ -446,11 +446,10 @@ GLFWvidmode* _glfwPlatformGetVideoModes(int* found)
         return 0;
     }
 
-    // Build array of available RGB channel depths
-
     rgbs = (int*) malloc(sizeof(int) * visualCount);
     rgbCount = 0;
 
+#if defined(_GLFW_GLX)
     for (i = 0;  i < visualCount;  i++)
     {
         int gl, rgba, rgb, r, g, b;
@@ -485,6 +484,7 @@ GLFWvidmode* _glfwPlatformGetVideoModes(int* found)
     }
 
     XFree(visuals);
+#endif
 
     // Build all permutations of channel depths and resolutions
 

src/x11_init.c

@@ -693,6 +693,11 @@ int _glfwPlatformTerminate(void)
 const char* _glfwPlatformGetVersionString(void)
 {
     const char* version = _GLFW_VERSION_FULL
+#if defined(_GLFW_GLX)
+        " GLX"
+#elif defined(_GLFW_EGL)
+        " EGL"
+#endif
 #if defined(_GLFW_HAS_XRANDR)
         " XRandR"
 #endif
@@ -711,8 +716,12 @@ const char* _glfwPlatformGetVersionString(void)
         " glXGetProcAddressARB"
 #elif defined(_GLFW_HAS_GLXGETPROCADDRESSEXT)
         " glXGetProcAddressEXT"
+#elif defined(_GLFW_HAS_EGLGETPROCADDRESS)
+        " eglGetProcAddress"
 #elif defined(_GLFW_DLOPEN_LIBGL)
         " dlsym(libGL)"
+#elif defined(_GLFW_DLOPEN_LIBEGL)
+        " dlsym(libEGL)"
 #else
         " no-extension-support"
 #endif

src/x11_platform.h

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    X11/GLX
+// Platform:    X11
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@@ -38,15 +38,7 @@
 #include <X11/keysym.h>
 #include <X11/Xatom.h>
 
-#define GLX_GLXEXT_LEGACY
-#include <GL/glx.h>
-
-// This path may need to be changed if you build GLFW using your own setup
-// GLFW comes with its own copy of glxext.h since it uses some fairly new
-// extensions and not all operating systems come with an up-to-date version
-#include "../support/GL/glxext.h"
-
-// The XF86VidMode extension provides mode setting and gamma control
+// With XFree86, we can use the XF86VidMode extension
 #if defined(_GLFW_HAS_XF86VIDMODE)
  #include <X11/extensions/xf86vmode.h>
 #endif
@@ -56,36 +48,25 @@
  #include <X11/extensions/Xrandr.h>
 #endif
 
-// dlopen is used as a fallback function retrieval mechanism
-#if defined(_GLFW_HAS_DLOPEN)
- #include <dlfcn.h>
-#endif
-
 // The Xkb extension provides improved keyboard support
 #if defined(_GLFW_HAS_XKB)
  #include <X11/XKBlib.h>
 #endif
 
-// GLFW supports four different ways for getting addresses for GL/GLX
-// extension functions: glXGetProcAddress, glXGetProcAddressARB,
-// glXGetProcAddressEXT, and dlsym
-#if defined(_GLFW_HAS_GLXGETPROCADDRESSARB)
- #define _glfw_glXGetProcAddress(x) glXGetProcAddressARB(x)
-#elif defined(_GLFW_HAS_GLXGETPROCADDRESS)
- #define _glfw_glXGetProcAddress(x) glXGetProcAddress(x)
-#elif defined(_GLFW_HAS_GLXGETPROCADDRESSEXT)
- #define _glfw_glXGetProcAddress(x) glXGetProcAddressEXT(x)
-#elif defined(_GLFW_HAS_DLOPEN)
- #define _glfw_glXGetProcAddress(x) dlsym(_glfwLibrary.GLX.libGL, x)
- #define _GLFW_DLOPEN_LIBGL
+#if defined(_GLFW_GLX)
+ #define _GLFW_X11_CONTEXT_VISUAL window->GLX.visual
+ #include "glx_platform.h"
+#elif defined(_GLFW_EGL)
+ #define _GLFW_X11_CONTEXT_VISUAL window->EGL.visual
+ #define _GLFW_EGL_NATIVE_WINDOW  window->X11.handle
+ #define _GLFW_EGL_NATIVE_DISPLAY _glfwLibrary.X11.display
+ #include "egl_platform.h"
 #else
- #error "No OpenGL entry point retrieval mechanism was enabled"
+ #error "No supported context creation API selected"
 #endif
 
-#define _GLFW_PLATFORM_WINDOW_STATE  _GLFWwindowX11 X11
-#define _GLFW_PLATFORM_CONTEXT_STATE _GLFWcontextGLX GLX
+#define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowX11  X11
 #define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryX11 X11
-#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryGLX GLX
 
 // Clipboard format atom indices
 #define _GLFW_CLIPBOARD_FORMAT_UTF8     0
@@ -98,10 +79,6 @@
 #define _GLFW_CONVERSION_SUCCEEDED      1
 #define _GLFW_CONVERSION_FAILED         2
 
-#ifndef GLX_MESA_swap_control
-typedef int (*PFNGLXSWAPINTERVALMESAPROC)(int);
-#endif
-
 
 //========================================================================
 // GLFW platform specific types
@@ -113,17 +90,6 @@ typedef int (*PFNGLXSWAPINTERVALMESAPROC)(int);
 typedef intptr_t GLFWintptr;
 
 
-//------------------------------------------------------------------------
-// Platform-specific OpenGL context structure
-//------------------------------------------------------------------------
-typedef struct _GLFWcontextGLX
-{
-    GLXContext    context;           // OpenGL rendering context
-    XVisualInfo*  visual;            // Visual for selected GLXFBConfig
-
-} _GLFWcontextGLX;
-
-
 //------------------------------------------------------------------------
 // Platform-specific window structure
 //------------------------------------------------------------------------
@@ -251,40 +217,6 @@ typedef struct _GLFWlibraryX11
 } _GLFWlibraryX11;
 
 
-//------------------------------------------------------------------------
-// Platform-specific library global data for GLX
-//------------------------------------------------------------------------
-typedef struct _GLFWlibraryGLX
-{
-    // Server-side GLX version
-    int             majorVersion, minorVersion;
-
-    // GLX extensions
-    PFNGLXSWAPINTERVALSGIPROC             SwapIntervalSGI;
-    PFNGLXSWAPINTERVALEXTPROC             SwapIntervalEXT;
-    PFNGLXSWAPINTERVALMESAPROC            SwapIntervalMESA;
-    PFNGLXGETFBCONFIGATTRIBSGIXPROC       GetFBConfigAttribSGIX;
-    PFNGLXCHOOSEFBCONFIGSGIXPROC          ChooseFBConfigSGIX;
-    PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC CreateContextWithConfigSGIX;
-    PFNGLXGETVISUALFROMFBCONFIGSGIXPROC   GetVisualFromFBConfigSGIX;
-    PFNGLXCREATECONTEXTATTRIBSARBPROC     CreateContextAttribsARB;
-    GLboolean   SGIX_fbconfig;
-    GLboolean   SGI_swap_control;
-    GLboolean   EXT_swap_control;
-    GLboolean   MESA_swap_control;
-    GLboolean   ARB_multisample;
-    GLboolean   ARB_framebuffer_sRGB;
-    GLboolean   ARB_create_context;
-    GLboolean   ARB_create_context_profile;
-    GLboolean   ARB_create_context_robustness;
-    GLboolean   EXT_create_context_es2_profile;
-
-#if defined(_GLFW_DLOPEN_LIBGL)
-    void*           libGL;  // dlopen handle for libGL.so
-#endif
-} _GLFWlibraryGLX;
-
-
 //========================================================================
 // Prototypes for platform specific internal functions
 //========================================================================
@@ -303,7 +235,6 @@ int _glfwCreateContext(_GLFWwindow* window,
                        const _GLFWwndconfig* wndconfig,
                        const _GLFWfbconfig* fbconfig);
 void _glfwDestroyContext(_GLFWwindow* window);
-XVisualInfo* _glfwGetContextVisual(_GLFWwindow* window);
 
 // Fullscreen support
 int  _glfwGetClosestVideoMode(int* width, int* height, int* rate);

src/x11_window.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    X11/GLX
+// Platform:    X11
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@@ -85,7 +85,7 @@ static GLboolean createWindow(_GLFWwindow* window,
 {
     unsigned long wamask;
     XSetWindowAttributes wa;
-    XVisualInfo* visual = _glfwGetContextVisual(window);
+    XVisualInfo* visual = _GLFW_X11_CONTEXT_VISUAL;
 
     // Every window needs a colormap
     // Create one based on the visual used by the current context

support/GL/eglext.h

@@ -0,0 +1,444 @@
+#ifndef __eglext_h_
+#define __eglext_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2007-2012 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be included
+** in all copies or substantial portions of the Materials.
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+#include <EGL/eglplatform.h>
+
+/*************************************************************/
+
+/* Header file version number */
+/* Current version at http://www.khronos.org/registry/egl/ */
+/* $Revision: 18175 $ on $Date: 2012-06-13 11:26:12 -0700 (Wed, 13 Jun 2012) $ */
+#define EGL_EGLEXT_VERSION 13
+
+#ifndef EGL_KHR_config_attribs
+#define EGL_KHR_config_attribs 1
+#define EGL_CONFORMANT_KHR			0x3042	/* EGLConfig attribute */
+#define EGL_VG_COLORSPACE_LINEAR_BIT_KHR	0x0020	/* EGL_SURFACE_TYPE bitfield */
+#define EGL_VG_ALPHA_FORMAT_PRE_BIT_KHR		0x0040	/* EGL_SURFACE_TYPE bitfield */
+#endif
+
+#ifndef EGL_KHR_lock_surface
+#define EGL_KHR_lock_surface 1
+#define EGL_READ_SURFACE_BIT_KHR		0x0001	/* EGL_LOCK_USAGE_HINT_KHR bitfield */
+#define EGL_WRITE_SURFACE_BIT_KHR		0x0002	/* EGL_LOCK_USAGE_HINT_KHR bitfield */
+#define EGL_LOCK_SURFACE_BIT_KHR		0x0080	/* EGL_SURFACE_TYPE bitfield */
+#define EGL_OPTIMAL_FORMAT_BIT_KHR		0x0100	/* EGL_SURFACE_TYPE bitfield */
+#define EGL_MATCH_FORMAT_KHR			0x3043	/* EGLConfig attribute */
+#define EGL_FORMAT_RGB_565_EXACT_KHR		0x30C0	/* EGL_MATCH_FORMAT_KHR value */
+#define EGL_FORMAT_RGB_565_KHR			0x30C1	/* EGL_MATCH_FORMAT_KHR value */
+#define EGL_FORMAT_RGBA_8888_EXACT_KHR		0x30C2	/* EGL_MATCH_FORMAT_KHR value */
+#define EGL_FORMAT_RGBA_8888_KHR		0x30C3	/* EGL_MATCH_FORMAT_KHR value */
+#define EGL_MAP_PRESERVE_PIXELS_KHR		0x30C4	/* eglLockSurfaceKHR attribute */
+#define EGL_LOCK_USAGE_HINT_KHR			0x30C5	/* eglLockSurfaceKHR attribute */
+#define EGL_BITMAP_POINTER_KHR			0x30C6	/* eglQuerySurface attribute */
+#define EGL_BITMAP_PITCH_KHR			0x30C7	/* eglQuerySurface attribute */
+#define EGL_BITMAP_ORIGIN_KHR			0x30C8	/* eglQuerySurface attribute */
+#define EGL_BITMAP_PIXEL_RED_OFFSET_KHR		0x30C9	/* eglQuerySurface attribute */
+#define EGL_BITMAP_PIXEL_GREEN_OFFSET_KHR	0x30CA	/* eglQuerySurface attribute */
+#define EGL_BITMAP_PIXEL_BLUE_OFFSET_KHR	0x30CB	/* eglQuerySurface attribute */
+#define EGL_BITMAP_PIXEL_ALPHA_OFFSET_KHR	0x30CC	/* eglQuerySurface attribute */
+#define EGL_BITMAP_PIXEL_LUMINANCE_OFFSET_KHR	0x30CD	/* eglQuerySurface attribute */
+#define EGL_LOWER_LEFT_KHR			0x30CE	/* EGL_BITMAP_ORIGIN_KHR value */
+#define EGL_UPPER_LEFT_KHR			0x30CF	/* EGL_BITMAP_ORIGIN_KHR value */
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglLockSurfaceKHR (EGLDisplay display, EGLSurface surface, const EGLint *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglUnlockSurfaceKHR (EGLDisplay display, EGLSurface surface);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLLOCKSURFACEKHRPROC) (EGLDisplay display, EGLSurface surface, const EGLint *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLUNLOCKSURFACEKHRPROC) (EGLDisplay display, EGLSurface surface);
+#endif
+
+#ifndef EGL_KHR_image
+#define EGL_KHR_image 1
+#define EGL_NATIVE_PIXMAP_KHR			0x30B0	/* eglCreateImageKHR target */
+typedef void *EGLImageKHR;
+#define EGL_NO_IMAGE_KHR			((EGLImageKHR)0)
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLImageKHR EGLAPIENTRY eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImageKHR (EGLDisplay dpy, EGLImageKHR image);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLImageKHR (EGLAPIENTRYP PFNEGLCREATEIMAGEKHRPROC) (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYIMAGEKHRPROC) (EGLDisplay dpy, EGLImageKHR image);
+#endif
+
+#ifndef EGL_KHR_vg_parent_image
+#define EGL_KHR_vg_parent_image 1
+#define EGL_VG_PARENT_IMAGE_KHR			0x30BA	/* eglCreateImageKHR target */
+#endif
+
+#ifndef EGL_KHR_gl_texture_2D_image
+#define EGL_KHR_gl_texture_2D_image 1
+#define EGL_GL_TEXTURE_2D_KHR			0x30B1	/* eglCreateImageKHR target */
+#define EGL_GL_TEXTURE_LEVEL_KHR		0x30BC	/* eglCreateImageKHR attribute */
+#endif
+
+#ifndef EGL_KHR_gl_texture_cubemap_image
+#define EGL_KHR_gl_texture_cubemap_image 1
+#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR	0x30B3	/* eglCreateImageKHR target */
+#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR	0x30B4	/* eglCreateImageKHR target */
+#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR	0x30B5	/* eglCreateImageKHR target */
+#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR	0x30B6	/* eglCreateImageKHR target */
+#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR	0x30B7	/* eglCreateImageKHR target */
+#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR	0x30B8	/* eglCreateImageKHR target */
+#endif
+
+#ifndef EGL_KHR_gl_texture_3D_image
+#define EGL_KHR_gl_texture_3D_image 1
+#define EGL_GL_TEXTURE_3D_KHR			0x30B2	/* eglCreateImageKHR target */
+#define EGL_GL_TEXTURE_ZOFFSET_KHR		0x30BD	/* eglCreateImageKHR attribute */
+#endif
+
+#ifndef EGL_KHR_gl_renderbuffer_image
+#define EGL_KHR_gl_renderbuffer_image 1
+#define EGL_GL_RENDERBUFFER_KHR			0x30B9	/* eglCreateImageKHR target */
+#endif
+
+#if KHRONOS_SUPPORT_INT64   /* EGLTimeKHR requires 64-bit uint support */
+#ifndef EGL_KHR_reusable_sync
+#define EGL_KHR_reusable_sync 1
+
+typedef void* EGLSyncKHR;
+typedef khronos_utime_nanoseconds_t EGLTimeKHR;
+
+#define EGL_SYNC_STATUS_KHR			0x30F1
+#define EGL_SIGNALED_KHR			0x30F2
+#define EGL_UNSIGNALED_KHR			0x30F3
+#define EGL_TIMEOUT_EXPIRED_KHR			0x30F5
+#define EGL_CONDITION_SATISFIED_KHR		0x30F6
+#define EGL_SYNC_TYPE_KHR			0x30F7
+#define EGL_SYNC_REUSABLE_KHR			0x30FA
+#define EGL_SYNC_FLUSH_COMMANDS_BIT_KHR		0x0001	/* eglClientWaitSyncKHR <flags> bitfield */
+#define EGL_FOREVER_KHR				0xFFFFFFFFFFFFFFFFull
+#define EGL_NO_SYNC_KHR				((EGLSyncKHR)0)
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync);
+EGLAPI EGLint EGLAPIENTRY eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
+EGLAPI EGLBoolean EGLAPIENTRY eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode);
+EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLSyncKHR (EGLAPIENTRYP PFNEGLCREATESYNCKHRPROC) (EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync);
+typedef EGLint (EGLAPIENTRYP PFNEGLCLIENTWAITSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSIGNALSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);
+#endif
+#endif
+
+#ifndef EGL_KHR_image_base
+#define EGL_KHR_image_base 1
+/* Most interfaces defined by EGL_KHR_image_pixmap above */
+#define EGL_IMAGE_PRESERVED_KHR			0x30D2	/* eglCreateImageKHR attribute */
+#endif
+
+#ifndef EGL_KHR_image_pixmap
+#define EGL_KHR_image_pixmap 1
+/* Interfaces defined by EGL_KHR_image above */
+#endif
+
+#ifndef EGL_IMG_context_priority
+#define EGL_IMG_context_priority 1
+#define EGL_CONTEXT_PRIORITY_LEVEL_IMG		0x3100
+#define EGL_CONTEXT_PRIORITY_HIGH_IMG		0x3101
+#define EGL_CONTEXT_PRIORITY_MEDIUM_IMG		0x3102
+#define EGL_CONTEXT_PRIORITY_LOW_IMG		0x3103
+#endif
+
+#ifndef EGL_KHR_lock_surface2
+#define EGL_KHR_lock_surface2 1
+#define EGL_BITMAP_PIXEL_SIZE_KHR		0x3110
+#endif
+
+#ifndef EGL_NV_coverage_sample
+#define EGL_NV_coverage_sample 1
+#define EGL_COVERAGE_BUFFERS_NV			0x30E0
+#define EGL_COVERAGE_SAMPLES_NV			0x30E1
+#endif
+
+#ifndef EGL_NV_depth_nonlinear
+#define EGL_NV_depth_nonlinear 1
+#define EGL_DEPTH_ENCODING_NV			0x30E2
+#define EGL_DEPTH_ENCODING_NONE_NV 0
+#define EGL_DEPTH_ENCODING_NONLINEAR_NV		0x30E3
+#endif
+
+#if KHRONOS_SUPPORT_INT64   /* EGLTimeNV requires 64-bit uint support */
+#ifndef EGL_NV_sync
+#define EGL_NV_sync 1
+#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_NV	0x30E6
+#define EGL_SYNC_STATUS_NV			0x30E7
+#define EGL_SIGNALED_NV				0x30E8
+#define EGL_UNSIGNALED_NV			0x30E9
+#define EGL_SYNC_FLUSH_COMMANDS_BIT_NV		0x0001
+#define EGL_FOREVER_NV				0xFFFFFFFFFFFFFFFFull
+#define EGL_ALREADY_SIGNALED_NV			0x30EA
+#define EGL_TIMEOUT_EXPIRED_NV			0x30EB
+#define EGL_CONDITION_SATISFIED_NV		0x30EC
+#define EGL_SYNC_TYPE_NV			0x30ED
+#define EGL_SYNC_CONDITION_NV			0x30EE
+#define EGL_SYNC_FENCE_NV			0x30EF
+#define EGL_NO_SYNC_NV				((EGLSyncNV)0)
+typedef void* EGLSyncNV;
+typedef khronos_utime_nanoseconds_t EGLTimeNV;
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLSyncNV EGLAPIENTRY eglCreateFenceSyncNV (EGLDisplay dpy, EGLenum condition, const EGLint *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglDestroySyncNV (EGLSyncNV sync);
+EGLAPI EGLBoolean EGLAPIENTRY eglFenceNV (EGLSyncNV sync);
+EGLAPI EGLint EGLAPIENTRY eglClientWaitSyncNV (EGLSyncNV sync, EGLint flags, EGLTimeNV timeout);
+EGLAPI EGLBoolean EGLAPIENTRY eglSignalSyncNV (EGLSyncNV sync, EGLenum mode);
+EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttribNV (EGLSyncNV sync, EGLint attribute, EGLint *value);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLSyncNV (EGLAPIENTRYP PFNEGLCREATEFENCESYNCNVPROC) (EGLDisplay dpy, EGLenum condition, const EGLint *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSYNCNVPROC) (EGLSyncNV sync);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLFENCENVPROC) (EGLSyncNV sync);
+typedef EGLint (EGLAPIENTRYP PFNEGLCLIENTWAITSYNCNVPROC) (EGLSyncNV sync, EGLint flags, EGLTimeNV timeout);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSIGNALSYNCNVPROC) (EGLSyncNV sync, EGLenum mode);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBNVPROC) (EGLSyncNV sync, EGLint attribute, EGLint *value);
+#endif
+#endif
+
+#if KHRONOS_SUPPORT_INT64   /* Dependent on EGL_KHR_reusable_sync which requires 64-bit uint support */
+#ifndef EGL_KHR_fence_sync
+#define EGL_KHR_fence_sync 1
+/* Reuses most tokens and entry points from EGL_KHR_reusable_sync */
+#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR	0x30F0
+#define EGL_SYNC_CONDITION_KHR			0x30F8
+#define EGL_SYNC_FENCE_KHR			0x30F9
+#endif
+#endif
+
+#ifndef EGL_HI_clientpixmap
+#define EGL_HI_clientpixmap 1
+
+/* Surface Attribute */
+#define EGL_CLIENT_PIXMAP_POINTER_HI		0x8F74
+/*
+ * Structure representing a client pixmap
+ * (pixmap's data is in client-space memory).
+ */
+struct EGLClientPixmapHI
+{
+	void*		pData;
+	EGLint		iWidth;
+	EGLint		iHeight;
+	EGLint		iStride;
+};
+
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurfaceHI(EGLDisplay dpy, EGLConfig config, struct EGLClientPixmapHI* pixmap);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPIXMAPSURFACEHIPROC) (EGLDisplay dpy, EGLConfig config, struct EGLClientPixmapHI* pixmap);
+#endif	/* EGL_HI_clientpixmap */
+
+#ifndef EGL_HI_colorformats
+#define EGL_HI_colorformats 1
+/* Config Attribute */
+#define EGL_COLOR_FORMAT_HI			0x8F70
+/* Color Formats */
+#define EGL_COLOR_RGB_HI			0x8F71
+#define EGL_COLOR_RGBA_HI			0x8F72
+#define EGL_COLOR_ARGB_HI			0x8F73
+#endif /* EGL_HI_colorformats */
+
+#ifndef EGL_MESA_drm_image
+#define EGL_MESA_drm_image 1
+#define EGL_DRM_BUFFER_FORMAT_MESA		0x31D0	    /* CreateDRMImageMESA attribute */
+#define EGL_DRM_BUFFER_USE_MESA			0x31D1	    /* CreateDRMImageMESA attribute */
+#define EGL_DRM_BUFFER_FORMAT_ARGB32_MESA	0x31D2	    /* EGL_IMAGE_FORMAT_MESA attribute value */
+#define EGL_DRM_BUFFER_MESA			0x31D3	    /* eglCreateImageKHR target */
+#define EGL_DRM_BUFFER_STRIDE_MESA		0x31D4
+#define EGL_DRM_BUFFER_USE_SCANOUT_MESA		0x00000001  /* EGL_DRM_BUFFER_USE_MESA bits */
+#define EGL_DRM_BUFFER_USE_SHARE_MESA		0x00000002  /* EGL_DRM_BUFFER_USE_MESA bits */
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLImageKHR EGLAPIENTRY eglCreateDRMImageMESA (EGLDisplay dpy, const EGLint *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglExportDRMImageMESA (EGLDisplay dpy, EGLImageKHR image, EGLint *name, EGLint *handle, EGLint *stride);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLImageKHR (EGLAPIENTRYP PFNEGLCREATEDRMIMAGEMESAPROC) (EGLDisplay dpy, const EGLint *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLEXPORTDRMIMAGEMESAPROC) (EGLDisplay dpy, EGLImageKHR image, EGLint *name, EGLint *handle, EGLint *stride);
+#endif
+
+#ifndef EGL_NV_post_sub_buffer
+#define EGL_NV_post_sub_buffer 1
+#define EGL_POST_SUB_BUFFER_SUPPORTED_NV	0x30BE
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglPostSubBufferNV (EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLPOSTSUBBUFFERNVPROC) (EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height);
+#endif
+
+#ifndef EGL_ANGLE_query_surface_pointer
+#define EGL_ANGLE_query_surface_pointer 1
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surface, EGLint attribute, void **value);
+#endif
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSURFACEPOINTERANGLEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint attribute, void **value);
+#endif
+
+#ifndef EGL_ANGLE_surface_d3d_texture_2d_share_handle
+#define EGL_ANGLE_surface_d3d_texture_2d_share_handle 1
+#define EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE	0x3200
+#endif
+
+#ifndef EGL_NV_coverage_sample_resolve
+#define EGL_NV_coverage_sample_resolve 1
+#define EGL_COVERAGE_SAMPLE_RESOLVE_NV		0x3131
+#define EGL_COVERAGE_SAMPLE_RESOLVE_DEFAULT_NV	0x3132
+#define EGL_COVERAGE_SAMPLE_RESOLVE_NONE_NV	0x3133
+#endif
+
+#if KHRONOS_SUPPORT_INT64   /* EGLuint64NV requires 64-bit uint support */
+#ifndef EGL_NV_system_time
+#define EGL_NV_system_time 1
+
+typedef khronos_utime_nanoseconds_t EGLuint64NV;
+
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeFrequencyNV(void);
+EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeNV(void);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLuint64NV (EGLAPIENTRYP PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC) (void);
+typedef EGLuint64NV (EGLAPIENTRYP PFNEGLGETSYSTEMTIMENVPROC) (void);
+#endif
+#endif
+
+#if KHRONOS_SUPPORT_INT64 /* EGLuint64KHR requires 64-bit uint support */
+#ifndef EGL_KHR_stream
+#define EGL_KHR_stream 1
+typedef void* EGLStreamKHR;
+typedef khronos_uint64_t EGLuint64KHR;
+#define EGL_NO_STREAM_KHR			    ((EGLStreamKHR)0)
+#define EGL_CONSUMER_LATENCY_USEC_KHR		    0x3210
+#define EGL_PRODUCER_FRAME_KHR			    0x3212
+#define EGL_CONSUMER_FRAME_KHR			    0x3213
+#define EGL_STREAM_STATE_KHR			    0x3214
+#define EGL_STREAM_STATE_CREATED_KHR		    0x3215
+#define EGL_STREAM_STATE_CONNECTING_KHR		    0x3216
+#define EGL_STREAM_STATE_EMPTY_KHR		    0x3217
+#define EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR    0x3218
+#define EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR    0x3219
+#define EGL_STREAM_STATE_DISCONNECTED_KHR	    0x321A
+#define EGL_BAD_STREAM_KHR			    0x321B
+#define EGL_BAD_STATE_KHR			    0x321C
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLStreamKHR EGLAPIENTRY eglCreateStreamKHR(EGLDisplay dpy, const EGLint *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglDestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream);
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamAttribKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint value);
+EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint *value);
+EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamu64KHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLuint64KHR *value);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLStreamKHR (EGLAPIENTRYP PFNEGLCREATESTREAMKHRPROC)(EGLDisplay dpy, const EGLint *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSTREAMKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMATTRIBKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint *value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMU64KHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLuint64KHR *value);
+#endif
+#endif
+
+#ifdef EGL_KHR_stream /* Requires KHR_stream extension */
+#ifndef EGL_KHR_stream_consumer_gltexture
+#define EGL_KHR_stream_consumer_gltexture 1
+#define EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR	    0x321E
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EGLStreamKHR stream);
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR stream);
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR stream);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERACQUIREKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERRELEASEKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
+#endif
+#endif
+
+#ifdef EGL_KHR_stream /* Requires KHR_stream extension */
+#ifndef EGL_KHR_stream_producer_eglsurface
+#define EGL_KHR_stream_producer_eglsurface 1
+#define EGL_STREAM_BIT_KHR			    0x0800
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLSurface EGLAPIENTRY eglCreateStreamProducerSurfaceKHR(EGLDisplay dpy, EGLConfig config, EGLStreamKHR stream, const EGLint *attrib_list);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC)(EGLDisplay dpy, EGLConfig config, EGLStreamKHR stream, const EGLint *attrib_list);
+#endif
+#endif
+
+#ifdef EGL_KHR_stream /* Requires KHR_stream extension */
+#ifndef EGL_KHR_stream_producer_aldatalocator
+#define EGL_KHR_stream_producer_aldatalocator 1
+#endif
+#endif
+
+#ifdef EGL_KHR_stream /* Requires KHR_stream extension */
+#ifndef EGL_KHR_stream_fifo
+#define EGL_KHR_stream_fifo 1
+/* reuse EGLTimeKHR */
+#define EGL_STREAM_FIFO_LENGTH_KHR		    0x31FC
+#define EGL_STREAM_TIME_NOW_KHR			    0x31FD
+#define EGL_STREAM_TIME_CONSUMER_KHR		    0x31FE
+#define EGL_STREAM_TIME_PRODUCER_KHR		    0x31FF
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamTimeKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLTimeKHR *value);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMTIMEKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLTimeKHR *value);
+#endif
+#endif
+
+#ifndef EGL_EXT_create_context_robustness
+#define EGL_EXT_create_context_robustness 1
+#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT	    0x30BF
+#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT 0x3138
+#define EGL_NO_RESET_NOTIFICATION_EXT		    0x31BE
+#define EGL_LOSE_CONTEXT_ON_RESET_EXT		    0x31BF
+#endif
+
+#ifndef EGL_ANGLE_d3d_share_handle_client_buffer
+#define EGL_ANGLE_d3d_share_handle_client_buffer 1
+/* reuse EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE */
+#endif
+
+#ifndef EGL_KHR_create_context
+#define EGL_KHR_create_context 1
+#define EGL_CONTEXT_MAJOR_VERSION_KHR			    EGL_CONTEXT_CLIENT_VERSION
+#define EGL_CONTEXT_MINOR_VERSION_KHR			    0x30FB
+#define EGL_CONTEXT_FLAGS_KHR				    0x30FC
+#define EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR		    0x30FD
+#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR  0x31BD
+#define EGL_NO_RESET_NOTIFICATION_KHR			    0x31BE
+#define EGL_LOSE_CONTEXT_ON_RESET_KHR			    0x31BF
+#define EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR		    0x00000001
+#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR	    0x00000002
+#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR	    0x00000004
+#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR		    0x00000001
+#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR    0x00000002
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif