Make the shaders work on NVidia

[gltest.git] / eglbackend.cpp

diff --git a/eglbackend.cpp b/eglbackend.cpp
index a9e20194003a998d4f1cffe47f2a17b4bdec9378..47e03844d0462497bcd1949c5d1f2f3bd8a6d56a 100644 (file)
--- a/eglbackend.cpp
+++ b/eglbackend.cpp
@@ -17,13 +17,17 @@
  */
 
 #include "eglbackend.h"
  */
 
 #include "eglbackend.h"

+#include "glutil.h"

 
 

-#include <stdlib.h>

 #include <stdio.h>
 #include <assert.h>
 
 #include <EGL/eglext.h>
 
 #include <stdio.h>
 #include <assert.h>
 
 #include <EGL/eglext.h>
 

+#if !defined(CON_GL1) && !defined(CON_GL3) && !defined(CON_GLES2)
+#error "Valid GL contexts for EGL are: GL1, GL3, GLES2"
+#endif
+

 static const char *eglErrorToString(EGLint e)
 {
 #define CASE(name) case name: return #name
 static const char *eglErrorToString(EGLint e)
 {
 #define CASE(name) case name: return #name


@@ -42,26 +46,33 @@ static const char *eglErrorToString(EGLint e)
 #undef CASE
 }
 
 #undef CASE
 }
 

-static void exitEglError(const char *what)
+static void dieEgl(const char *what)

 {
        EGLint e = eglGetError();
 {
        EGLint e = eglGetError();

-       fprintf(stderr, "EGL error %d (%s): %s\n", e, eglErrorToString(e), what);
-       exit(1);
+       die("EGL error %d (%s): %s\n", e, eglErrorToString(e), what);

 }
 
 }
 

-static const EGLint context_attribs[] = {
-#ifdef USE_GLES
-       EGL_CONTEXT_CLIENT_VERSION, 2,
-#endif
-       EGL_NONE
-};
-static const EGLint config_attribs[] = {
+static const EGLint configAttribs[] = {

        EGL_RED_SIZE,             4,
        EGL_GREEN_SIZE,           4,
        EGL_BLUE_SIZE,            4,
        EGL_RED_SIZE,             4,
        EGL_GREEN_SIZE,           4,
        EGL_BLUE_SIZE,            4,

+#ifdef CON_GLES2
+       EGL_RENDERABLE_TYPE,      EGL_OPENGL_ES2_BIT,
+#else

        EGL_RENDERABLE_TYPE,      EGL_OPENGL_BIT,
        EGL_RENDERABLE_TYPE,      EGL_OPENGL_BIT,

+#endif

        EGL_NONE,
 };
        EGL_NONE,
 };

+static const EGLint contextAttribs[] = {
+#ifdef CON_GLES2
+       EGL_CONTEXT_CLIENT_VERSION, 2,
+#elif CON_GL3
+       EGL_CONTEXT_MAJOR_VERSION_KHR, 3,
+       EGL_CONTEXT_MINOR_VERSION_KHR, 0,
+       EGL_CONTEXT_FLAGS_KHR, EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR,
+#endif
+       EGL_NONE
+};

 
 VisualID EGLBackend::initialize(Display *xDisplay)
 {
 
 VisualID EGLBackend::initialize(Display *xDisplay)
 {


@@ -70,21 +81,35 @@ VisualID EGLBackend::initialize(Display *xDisplay)
                EGLint eglMajor, eglMinor;
                display = eglGetDisplay(xDisplay);
                if (display == EGL_NO_DISPLAY)
                EGLint eglMajor, eglMinor;
                display = eglGetDisplay(xDisplay);
                if (display == EGL_NO_DISPLAY)

-                       exitEglError("Failed to get EGL display");
+                       dieEgl("Failed to get EGL display");

                if (eglInitialize(display, &eglMajor, &eglMinor) == EGL_FALSE)
                if (eglInitialize(display, &eglMajor, &eglMinor) == EGL_FALSE)

-                       exitEglError("Failed to initialize EGL");
-               printf("Using EGL version %d.%d\n", eglMajor, eglMinor);
-#ifdef USE_GLES
+                       dieEgl("Failed to initialize EGL");
+               printf("Using EGL version: %d.%d\n", eglMajor, eglMinor);
+               if (eglMajor == 1 && eglMinor < 4) {
+                       // Choosing the GL context version requires EGL 1.3, creating an OpenGL 3 context requires EGL 1.4
+                       die("Need at least EGL 1.4 to function properly\n");
+               }
+#ifdef CON_GLES2

                if (eglBindAPI(EGL_OPENGL_ES_API) == EGL_FALSE)
 #else
                if (eglBindAPI(EGL_OPENGL_API) == EGL_FALSE)
 #endif
                if (eglBindAPI(EGL_OPENGL_ES_API) == EGL_FALSE)
 #else
                if (eglBindAPI(EGL_OPENGL_API) == EGL_FALSE)
 #endif

-                       exitEglError("Failed to bind API");
+                       dieEgl("Failed to bind API");
+               // check for the extension we need
+#ifdef CON_GL3
+               if (!haveEGLExtension("EGL_KHR_create_context")) {
+                       die("Required EGL extension EGL_KHR_create_context is not supported\n");
+               }
+#endif

                // get an appropriate config
                EGLConfig configs[1];
                EGLint count;
                // get an appropriate config
                EGLConfig configs[1];
                EGLint count;

-               if (eglChooseConfig(display, config_attribs, configs, 1, &count) == EGL_FALSE || count == 0)
-                       exitEglError("Failed to choose config");
+               if (eglChooseConfig(display, configAttribs, configs, 1, &count) == EGL_FALSE){
+                       dieEgl("Failed to choose framebuffer configuration");
+               }
+               if (count == 0) {
+                       die("Found no matching framebuffer configuration\n");
+               }

                config = configs[0];
        }
        // return visual ID
                config = configs[0];
        }
        // return visual ID


@@ -93,16 +118,26 @@ VisualID EGLBackend::initialize(Display *xDisplay)
        return (VisualID)val;
 }
 
        return (VisualID)val;
 }
 

+bool EGLBackend::haveEGLExtension(const std::string &name)
+{
+       assert(display != EGL_NO_DISPLAY);
+       std::string extensions = eglQueryString(display, EGL_EXTENSIONS);
+       return (std::string(" "+extensions+" ").find(" "+name+" ") != std::string::npos);
+}
+

 void EGLBackend::createContext(Window window)
 {
        assert(display != EGL_NO_DISPLAY && context == EGL_NO_CONTEXT);
        surface = eglCreateWindowSurface(display, config, window, NULL);
        // create an EGL context and use it with the surface
 void EGLBackend::createContext(Window window)
 {
        assert(display != EGL_NO_DISPLAY && context == EGL_NO_CONTEXT);
        surface = eglCreateWindowSurface(display, config, window, NULL);
        // create an EGL context and use it with the surface

-       context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribs);
+       context = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttribs);

        if (context == EGL_NO_CONTEXT)
        if (context == EGL_NO_CONTEXT)

-               exitEglError("Failed to create context");
+               dieEgl("Failed to create context");

        if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE)
        if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE)

-               exitEglError("Failed to make context current");
+               dieEgl("Failed to make context current");
+       printf("Using GL version: %s\n", glGetString(GL_VERSION));
+       // initialise GL utilities
+       resolveFunctionPointers(eglGetProcAddress);

 }
 
 EGLBackend::~EGLBackend()
 }
 
 EGLBackend::~EGLBackend()


@@ -122,25 +157,22 @@ void EGLBackend::swapBuffers() const
 {
        assert(context != EGL_NO_CONTEXT); // this implies the display is also initialized
        if (eglSwapBuffers(display, surface) == EGL_FALSE)
 {
        assert(context != EGL_NO_CONTEXT); // this implies the display is also initialized
        if (eglSwapBuffers(display, surface) == EGL_FALSE)

-               exitEglError("Failed to swap buffers");
+               dieEgl("Failed to swap buffers");

 }
 
 void EGLBackend::setSwapInterval(int i) const
 {
        assert(context != EGL_NO_CONTEXT);
        // check if swap interval value is supported
 }
 
 void EGLBackend::setSwapInterval(int i) const
 {
        assert(context != EGL_NO_CONTEXT);
        // check if swap interval value is supported

-       EGLint val;
-       eglGetConfigAttrib(display, config, EGL_MIN_SWAP_INTERVAL, &val);
-       if (i < val) {
-               fprintf(stderr, "Cannot set swap interval to %d, minimum supported value is %d\n", i, val);
-               exit(1);
+       if (i < 0) {
+               die("Cannot set swap interval to %d, must not be negative\n", i);

        }
        }

+       EGLint val;

        eglGetConfigAttrib(display, config, EGL_MAX_SWAP_INTERVAL, &val);
        if (i > val) {
        eglGetConfigAttrib(display, config, EGL_MAX_SWAP_INTERVAL, &val);
        if (i > val) {

-               fprintf(stderr, "Cannot set swap interval to %d, maximum supported value is %d\n", i, val);
-               exit(1);
+               die("Cannot set swap interval to %d, maximum supported value is %d\n", i, val);

        }
        // use it
        if (eglSwapInterval(display, i) == EGL_FALSE)
        }
        // use it
        if (eglSwapInterval(display, i) == EGL_FALSE)

-               exitEglError("Failed to set swap interval");
+               dieEgl("Failed to set swap interval");

 }
 }