We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

[patch] Fix X11 OpenGL ES support - hg export

SDL_x11opengles_fix.patch (text/plain), 49.16 KB, created by Scott Percival on 2011-07-03 06:41:51 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Scott Percival

Created: 2011-07-03 06:41:51 UTC

Size: 49.16 KB

patch

obsolete

># HG changeset patch
># User Scott Percival <scott@labyrinthdata.net.au>
># Date 1309690700 -28800
># Node ID 2a9204228f5e309e82641741bafcc05f045bf2d4
># Parent  c1ed57cbfd66e146a7af034a806377bb271b1696
>Improve support for OpenGL ES under X11
>
>diff -r c1ed57cbfd66 -r 2a9204228f5e configure.in
>--- a/configure.in	Wed Jun 22 10:33:48 2011 +0000
>+++ b/configure.in	Sun Jul 03 18:58:20 2011 +0800
>@@ -1438,6 +1438,57 @@
>     fi
> }
> 
>+dnl Check to see if OpenGL ES support is desired
>+AC_ARG_ENABLE(video-opengles,
>+AC_HELP_STRING([--enable-video-opengles], [include OpenGL ES support [[default=yes]]]),
>+              , enable_video_opengles=yes)
>+
>+dnl Find OpenGL ES
>+CheckOpenGLESX11()
>+{
>+    if test x$enable_video = xyes -a x$enable_video_opengles = xyes; then
>+        AC_MSG_CHECKING(for OpenGL ES (EGL) support)
>+        video_opengles=no
>+        AC_TRY_COMPILE([
>+         #include <EGL/egl.h>
>+        ],[
>+        ],[
>+        video_opengles=yes
>+        ])
>+        AC_MSG_RESULT($video_opengles)
>+        if test x$video_opengles = xyes; then
>+            AC_MSG_CHECKING(for OpenGL ES v1 headers)
>+            video_opengles_v1=no
>+            AC_TRY_COMPILE([
>+             #include <GLES/gl.h>
>+             #include <GLES/glext.h>
>+            ],[
>+            ],[
>+            video_opengles_v1=yes
>+            ])
>+            AC_MSG_RESULT($video_opengles_v1)
>+            if test x$video_opengles_v1 = xyes; then
>+                AC_DEFINE(SDL_VIDEO_OPENGL_ES, 1, [ ])
>+                AC_DEFINE(SDL_VIDEO_RENDER_OGL_ES, 1, [ ])
>+            fi
>+            AC_MSG_CHECKING(for OpenGL ES v2 headers)
>+            video_opengles_v2=no
>+            AC_TRY_COMPILE([
>+             #include <GLES2/gl2.h>
>+             #include <GLES2/gl2ext.h>
>+            ],[
>+            ],[
>+            video_opengles_v2=yes
>+            ])
>+            AC_MSG_RESULT($video_opengles_v2)
>+            if test x$video_opengles_v2 = xyes; then
>+                AC_DEFINE(SDL_VIDEO_OPENGL_ES2, 1, [ ])
>+                AC_DEFINE(SDL_VIDEO_RENDER_OGL_ES2, 1, [ ])
>+            fi
>+        fi
>+    fi
>+}
>+
> dnl Check for Windows OpenGL
> CheckWINDOWSGL()
> {
>@@ -1970,6 +2021,7 @@
>         CheckDirectFB
>         CheckFusionSound
>         CheckOpenGLX11
>+        CheckOpenGLESX11
>         CheckInputEvents
>         CheckTslib
>         CheckUSBHID
>diff -r c1ed57cbfd66 -r 2a9204228f5e include/SDL_config.h.in
>--- a/include/SDL_config.h.in	Wed Jun 22 10:33:48 2011 +0000
>+++ b/include/SDL_config.h.in	Sun Jul 03 18:58:20 2011 +0800
>@@ -268,6 +268,7 @@
> #undef SDL_VIDEO_RENDER_D3D
> #undef SDL_VIDEO_RENDER_OGL
> #undef SDL_VIDEO_RENDER_OGL_ES
>+#undef SDL_VIDEO_RENDER_OGL_ES2
> #undef SDL_VIDEO_RENDER_DIRECTFB
> 
> /* Enable OpenGL support */
>diff -r c1ed57cbfd66 -r 2a9204228f5e src/render/opengles/SDL_glesfuncs.h
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ b/src/render/opengles/SDL_glesfuncs.h	Sun Jul 03 18:58:20 2011 +0800
>@@ -0,0 +1,29 @@
>+SDL_PROC(void, glBindTexture, (GLenum, GLuint))
>+SDL_PROC(void, glBlendFunc, (GLenum, GLenum))
>+SDL_PROC(void, glClear, (GLbitfield))
>+SDL_PROC(void, glClearColor, (GLclampf, GLclampf, GLclampf, GLclampf))
>+SDL_PROC(void, glColor4f, (GLfloat, GLfloat, GLfloat, GLfloat))
>+SDL_PROC(void, glDeleteTextures, (GLsizei, const GLuint *))
>+SDL_PROC(void, glDisable, (GLenum))
>+SDL_PROC(void, glDisableClientState, (GLenum array))
>+SDL_PROC(void, glDrawArrays, (GLenum, GLint, GLsizei))
>+SDL_PROC(void, glDrawTexiOES, (GLint, GLint, GLint, GLint, GLint))
>+SDL_PROC(void, glEnable, (GLenum))
>+SDL_PROC(void, glEnableClientState, (GLenum))
>+SDL_PROC(void, glGenTextures, (GLsizei, GLuint *))
>+SDL_PROC(GLenum, glGetError, (void))
>+SDL_PROC(void, glGetIntegerv, (GLenum, GLint *))
>+SDL_PROC(void, glLoadIdentity, (void))
>+SDL_PROC(void, glMatrixMode, (GLenum))
>+SDL_PROC(void, glOrthof, (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat))
>+SDL_PROC(void, glPixelStorei, (GLenum, GLint))
>+SDL_PROC(void, glTexCoordPointer, (GLint, GLenum, GLsizei, const GLvoid *))
>+SDL_PROC(void, glTexEnvf, (GLenum, GLenum, GLfloat))
>+SDL_PROC(void, glTexImage2D, (GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
>+SDL_PROC(void, glTexParameteri, (GLenum, GLenum, GLint))
>+SDL_PROC(void, glTexParameteriv, (GLenum, GLenum, const GLint *))
>+SDL_PROC(void, glTexSubImage2D, (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
>+SDL_PROC(void, glVertexPointer, (GLint, GLenum, GLsizei, const GLvoid *))
>+SDL_PROC(void, glViewport, (GLint, GLint, GLsizei, GLsizei))
>+
>+/* vi: set ts=4 sw=4 expandtab: */
>diff -r c1ed57cbfd66 -r 2a9204228f5e src/render/opengles/SDL_render_gles.c
>--- a/src/render/opengles/SDL_render_gles.c	Wed Jun 22 10:33:48 2011 +0000
>+++ b/src/render/opengles/SDL_render_gles.c	Sun Jul 03 18:58:20 2011 +0800
>@@ -90,6 +90,10 @@
>         SDL_bool tex_coords;
>     } current;
> 
>+#define SDL_PROC(ret,func,params) ret (APIENTRY *func) params;
>+#include "SDL_glesfuncs.h"
>+#undef SDL_PROC
>+
>     SDL_bool useDrawTexture;
>     SDL_bool GL_OES_draw_texture_supported;
> } GLES_RenderData;
>@@ -140,6 +144,26 @@
>     SDL_SetError("%s: %s", prefix, error);
> }
> 
>+static int GLES_LoadFunctions(GLES_RenderData * data)
>+{
>+#ifdef __SDL_NOGETPROCADDR__
>+#define SDL_PROC(ret,func,params) data->func=func;
>+#else
>+#define SDL_PROC(ret,func,params) \
>+    do { \
>+        data->func = SDL_GL_GetProcAddress(#func); \
>+        if ( ! data->func ) { \
>+            SDL_SetError("Couldn't load GLES function %s: %s\n", #func, SDL_GetError()); \
>+            return -1; \
>+        } \
>+    } while ( 0 );  
>+#endif /* _SDL_NOGETPROCADDR_ */
>+
>+#include "SDL_glesfuncs.h"
>+#undef SDL_PROC
>+    return 0;
>+}
>+
> static SDL_GLContext SDL_CurrentContext = NULL;
> 
> static int
>@@ -174,14 +198,14 @@
>     data->current.blendMode = -1;
>     data->current.tex_coords = SDL_FALSE;
> 
>-    glDisable(GL_DEPTH_TEST);
>-    glDisable(GL_CULL_FACE);
>+    data->glDisable(GL_DEPTH_TEST);
>+    data->glDisable(GL_CULL_FACE);
> 
>-    glMatrixMode(GL_MODELVIEW);
>-    glLoadIdentity();
>+    data->glMatrixMode(GL_MODELVIEW);
>+    data->glLoadIdentity();
> 
>-    glEnableClientState(GL_VERTEX_ARRAY);
>-    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
>+    data->glEnableClientState(GL_VERTEX_ARRAY);
>+    data->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
> }
> 
> SDL_Renderer *
>@@ -192,6 +216,18 @@
>     GLES_RenderData *data;
>     GLint value;
> 
>+    Uint32 windowFlags;
>+    
>+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
>+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
>+    
>+    windowFlags = SDL_GetWindowFlags(window);
>+    if (!(windowFlags & SDL_WINDOW_OPENGL)) {
>+        if (SDL_RecreateWindow(window, windowFlags | SDL_WINDOW_OPENGL)) {
>+            return NULL;
>+        }
>+    }
>+
>     renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
>     if (!renderer) {
>         SDL_OutOfMemory();
>@@ -236,6 +272,11 @@
>         return NULL;
>     }
> 
>+    if (GLES_LoadFunctions(data) < 0) {
>+        GLES_DestroyRenderer(renderer);
>+        return NULL;
>+    }
>+
>     if (flags & SDL_RENDERER_PRESENTVSYNC) {
>         SDL_GL_SetSwapInterval(1);
>     } else {
>@@ -258,9 +299,9 @@
>     }
> #endif
> 
>-    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
>+    data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
>     renderer->info.max_texture_width = value;
>-    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
>+    data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
>     renderer->info.max_texture_height = value;
> 
>     /* Set up parameters for rendering */
>@@ -304,6 +345,7 @@
> static int
> GLES_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
> {
>+    GLES_RenderData *renderdata = (GLES_RenderData *) renderer->driverdata;
>     GLES_TextureData *data;
>     GLint internalFormat;
>     GLenum format, type;
>@@ -342,9 +384,9 @@
> 
>     texture->driverdata = data;
> 
>-    glGetError();
>-    glEnable(GL_TEXTURE_2D);
>-    glGenTextures(1, &data->texture);
>+    renderdata->glGetError();
>+    renderdata->glEnable(GL_TEXTURE_2D);
>+    renderdata->glGenTextures(1, &data->texture);
> 
>     data->type = GL_TEXTURE_2D;
>     /* no NPOV textures allowed in OpenGL ES (yet) */
>@@ -356,17 +398,17 @@
>     data->format = format;
>     data->formattype = type;
>     scaleMode = GetScaleQuality();
>-    glBindTexture(data->type, data->texture);
>-    glTexParameteri(data->type, GL_TEXTURE_MIN_FILTER, scaleMode);
>-    glTexParameteri(data->type, GL_TEXTURE_MAG_FILTER, scaleMode);
>-    glTexParameteri(data->type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
>-    glTexParameteri(data->type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
>+    renderdata->glBindTexture(data->type, data->texture);
>+    renderdata->glTexParameteri(data->type, GL_TEXTURE_MIN_FILTER, scaleMode);
>+    renderdata->glTexParameteri(data->type, GL_TEXTURE_MAG_FILTER, scaleMode);
>+    renderdata->glTexParameteri(data->type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
>+    renderdata->glTexParameteri(data->type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
> 
>-    glTexImage2D(data->type, 0, internalFormat, texture_w,
>+    renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w,
>                              texture_h, 0, format, type, NULL);
>-    glDisable(GL_TEXTURE_2D);
>+    renderdata->glDisable(GL_TEXTURE_2D);
> 
>-    result = glGetError();
>+    result = renderdata->glGetError();
>     if (result != GL_NO_ERROR) {
>         GLES_SetError("glTexImage2D()", result);
>         return -1;
>@@ -378,6 +420,8 @@
> GLES_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
>                    const SDL_Rect * rect, const void *pixels, int pitch)
> {
>+    GLES_RenderData *renderdata = (GLES_RenderData *) renderer->driverdata;
>+    
>     GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
>     Uint8 *blob = NULL;
>     Uint8 *src;
>@@ -412,11 +456,11 @@
>     }
> 
>     /* Create a texture subimage with the supplied data */
>-    glGetError();
>-    glEnable(data->type);
>-    glBindTexture(data->type, data->texture);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
>-    glTexSubImage2D(data->type,
>+    renderdata->glGetError();
>+    renderdata->glEnable(data->type);
>+    renderdata->glBindTexture(data->type, data->texture);
>+    renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
>+    renderdata->glTexSubImage2D(data->type,
>                     0,
>                     rect->x,
>                     rect->y,
>@@ -429,7 +473,7 @@
>         SDL_free(blob);
>     }
> 
>-    if (glGetError() != GL_NO_ERROR)
>+    if (renderdata->glGetError() != GL_NO_ERROR)
>     {
>         SDL_SetError("Failed to update texture");
>         return -1;
>@@ -474,12 +518,12 @@
>         return 0;
>     }
> 
>-    glViewport(renderer->viewport.x, renderer->viewport.y,
>+    data->glViewport(renderer->viewport.x, renderer->viewport.y,
>                renderer->viewport.w, renderer->viewport.h);
> 
>-    glMatrixMode(GL_PROJECTION);
>-    glLoadIdentity();
>-    glOrthof((GLfloat) 0,
>+    data->glMatrixMode(GL_PROJECTION);
>+    data->glLoadIdentity();
>+    data->glOrthof((GLfloat) 0,
> 			 (GLfloat) renderer->viewport.w,
>              (GLfloat) renderer->viewport.h,
>              (GLfloat) 0, 0.0, 1.0);
>@@ -492,7 +536,7 @@
>     Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
> 
>     if (color != data->current.color) {
>-        glColor4f((GLfloat) r * inv255f,
>+        data->glColor4f((GLfloat) r * inv255f,
>                         (GLfloat) g * inv255f,
>                         (GLfloat) b * inv255f,
>                         (GLfloat) a * inv255f);
>@@ -506,23 +550,23 @@
>     if (blendMode != data->current.blendMode) {
>         switch (blendMode) {
>         case SDL_BLENDMODE_NONE:
>-            glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
>-            glDisable(GL_BLEND);
>+            data->glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
>+            data->glDisable(GL_BLEND);
>             break;
>         case SDL_BLENDMODE_BLEND:
>-            glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
>-            glEnable(GL_BLEND);
>-            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
>+            data->glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
>+            data->glEnable(GL_BLEND);
>+            data->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
>             break;
>         case SDL_BLENDMODE_ADD:
>-            glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
>-            glEnable(GL_BLEND);
>-            glBlendFunc(GL_SRC_ALPHA, GL_ONE);
>+            data->glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
>+            data->glEnable(GL_BLEND);
>+            data->glBlendFunc(GL_SRC_ALPHA, GL_ONE);
>             break;
>         case SDL_BLENDMODE_MOD:
>-            glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
>-            glEnable(GL_BLEND);
>-            glBlendFunc(GL_ZERO, GL_SRC_COLOR);
>+            data->glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
>+            data->glEnable(GL_BLEND);
>+            data->glBlendFunc(GL_ZERO, GL_SRC_COLOR);
>             break;
>         }
>         data->current.blendMode = blendMode;
>@@ -534,9 +578,9 @@
> {
>     if (enabled != data->current.tex_coords) {
>         if (enabled) {
>-            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
>+            data->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
>         } else {
>-            glDisableClientState(GL_TEXTURE_COORD_ARRAY);
>+            data->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
>         }
>         data->current.tex_coords = enabled;
>     }
>@@ -562,14 +606,16 @@
> static int
> GLES_RenderClear(SDL_Renderer * renderer)
> {
>+    GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
>+
>     GLES_ActivateRenderer(renderer);
> 
>-    glClearColor((GLfloat) renderer->r * inv255f,
>+    data->glClearColor((GLfloat) renderer->r * inv255f,
>                  (GLfloat) renderer->g * inv255f,
>                  (GLfloat) renderer->b * inv255f,
>                  (GLfloat) renderer->a * inv255f);
> 
>-    glClear(GL_COLOR_BUFFER_BIT);
>+    data->glClear(GL_COLOR_BUFFER_BIT);
> 
>     return 0;
> }
>@@ -589,8 +635,8 @@
>         vertices[2*i+0] = (GLshort)points[i].x;
>         vertices[2*i+1] = (GLshort)points[i].y;
>     }
>-    glVertexPointer(2, GL_SHORT, 0, vertices);
>-    glDrawArrays(GL_POINTS, 0, count);
>+    data->glVertexPointer(2, GL_SHORT, 0, vertices);
>+    data->glDrawArrays(GL_POINTS, 0, count);
>     SDL_stack_free(vertices);
> 
>     return 0;
>@@ -611,14 +657,14 @@
>         vertices[2*i+0] = (GLshort)points[i].x;
>         vertices[2*i+1] = (GLshort)points[i].y;
>     }
>-    glVertexPointer(2, GL_SHORT, 0, vertices);
>+    data->glVertexPointer(2, GL_SHORT, 0, vertices);
>     if (count > 2 && 
>         points[0].x == points[count-1].x && points[0].y == points[count-1].y) {
>         /* GL_LINE_LOOP takes care of the final segment */
>         --count;
>-        glDrawArrays(GL_LINE_LOOP, 0, count);
>+        data->glDrawArrays(GL_LINE_LOOP, 0, count);
>     } else {
>-        glDrawArrays(GL_LINE_STRIP, 0, count);
>+        data->glDrawArrays(GL_LINE_STRIP, 0, count);
>     }
>     SDL_stack_free(vertices);
> 
>@@ -650,8 +696,8 @@
>         vertices[6] = maxx;
>         vertices[7] = maxy;
> 
>-        glVertexPointer(2, GL_SHORT, 0, vertices);
>-        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
>+        data->glVertexPointer(2, GL_SHORT, 0, vertices);
>+        data->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
>     }
> 
>     return 0;
>@@ -669,9 +715,9 @@
> 
>     GLES_ActivateRenderer(renderer);
> 
>-    glEnable(GL_TEXTURE_2D);
>+    data->glEnable(GL_TEXTURE_2D);
> 
>-    glBindTexture(texturedata->type, texturedata->texture);
>+    data->glBindTexture(texturedata->type, texturedata->texture);
> 
>     if (texture->modMode) {
>         GLES_SetColor(data, texture->r, texture->g, texture->b, texture->a);
>@@ -694,9 +740,9 @@
>         cropRect[1] = srcrect->y + srcrect->h;
>         cropRect[2] = srcrect->w;
>         cropRect[3] = -srcrect->h;
>-        glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES,
>+        data->glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES,
>                                cropRect);
>-        glDrawTexiOES(dstrect->x, h - dstrect->y - dstrect->h, 0,
>+        data->glDrawTexiOES(dstrect->x, h - dstrect->y - dstrect->h, 0,
>                             dstrect->w, dstrect->h);
>     } else {
> 
>@@ -735,11 +781,11 @@
>         texCoords[6] = maxu;
>         texCoords[7] = maxv;
> 
>-        glVertexPointer(2, GL_SHORT, 0, vertices);
>-        glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
>-        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
>+        data->glVertexPointer(2, GL_SHORT, 0, vertices);
>+        data->glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
>+        data->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
>     }
>-    glDisable(GL_TEXTURE_2D);
>+    data->glDisable(GL_TEXTURE_2D);
> 
>     return 0;
> }
>@@ -755,6 +801,8 @@
> static void
> GLES_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
> {
>+    GLES_RenderData *renderdata = (GLES_RenderData *) renderer->driverdata;
>+
>     GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
> 
>     GLES_ActivateRenderer(renderer);
>@@ -763,7 +811,7 @@
>         return;
>     }
>     if (data->texture) {
>-        glDeleteTextures(1, &data->texture);
>+        renderdata->glDeleteTextures(1, &data->texture);
>     }
>     if (data->pixels) {
>         SDL_free(data->pixels);
>diff -r c1ed57cbfd66 -r 2a9204228f5e src/render/opengles2/SDL_gles2funcs.h
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ b/src/render/opengles2/SDL_gles2funcs.h	Sun Jul 03 18:58:20 2011 +0800
>@@ -0,0 +1,40 @@
>+SDL_PROC(void, glActiveTexture, (GLenum))
>+SDL_PROC(void, glAttachShader, (GLuint, GLuint))
>+SDL_PROC(void, glBindAttribLocation, (GLuint, GLuint, const char *))
>+SDL_PROC(void, glBindTexture, (GLenum, GLuint))
>+SDL_PROC(void, glBlendFunc, (GLenum, GLenum))
>+SDL_PROC(void, glClear, (GLbitfield))
>+SDL_PROC(void, glClearColor, (GLclampf, GLclampf, GLclampf, GLclampf))
>+SDL_PROC(void, glCompileShader, (GLuint))
>+SDL_PROC(GLuint, glCreateProgram, (void))
>+SDL_PROC(GLuint, glCreateShader, (GLenum))
>+SDL_PROC(void, glDeleteProgram, (GLuint))
>+SDL_PROC(void, glDeleteShader, (GLuint))
>+SDL_PROC(void, glDeleteTextures, (GLsizei, const GLuint *))
>+SDL_PROC(void, glDisable, (GLenum))
>+SDL_PROC(void, glDisableVertexAttribArray, (GLuint))
>+SDL_PROC(void, glDrawArrays, (GLenum, GLint, GLsizei))
>+SDL_PROC(void, glEnable, (GLenum))
>+SDL_PROC(void, glEnableVertexAttribArray, (GLuint))
>+SDL_PROC(void, glGenTextures, (GLsizei, GLuint *))
>+SDL_PROC(void, glGetBooleanv, (GLenum, GLboolean *))
>+SDL_PROC(const GLubyte *, glGetString, (GLenum))
>+SDL_PROC(GLenum, glGetError, (void))
>+SDL_PROC(void, glGetIntegerv, (GLenum, GLint *))
>+SDL_PROC(void, glGetProgramiv, (GLuint, GLenum, GLint *))
>+SDL_PROC(void, glGetShaderInfoLog, (GLuint, GLsizei, GLsizei *, char *))
>+SDL_PROC(void, glGetShaderiv, (GLuint, GLenum, GLint *))
>+SDL_PROC(GLint, glGetUniformLocation, (GLuint, const char *))
>+SDL_PROC(void, glLinkProgram, (GLuint))
>+SDL_PROC(void, glPixelStorei, (GLenum, GLint))
>+SDL_PROC(void, glShaderBinary, (GLsizei, const GLuint *, GLenum, const void *, GLsizei))
>+SDL_PROC(void, glShaderSource, (GLuint, GLsizei, const char **, const GLint *))
>+SDL_PROC(void, glTexImage2D, (GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const void *))
>+SDL_PROC(void, glTexParameteri, (GLenum, GLenum, GLint))
>+SDL_PROC(void, glTexSubImage2D, (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
>+SDL_PROC(void, glUniform1i, (GLint, GLint))
>+SDL_PROC(void, glUniform4f, (GLint, GLfloat, GLfloat, GLfloat, GLfloat))
>+SDL_PROC(void, glUniformMatrix4fv, (GLint, GLsizei, GLboolean, const GLfloat *))
>+SDL_PROC(void, glUseProgram, (GLuint))
>+SDL_PROC(void, glVertexAttribPointer, (GLuint, GLint, GLenum, GLboolean, GLsizei, const void *))
>+SDL_PROC(void, glViewport, (GLint, GLint, GLsizei, GLsizei))
>diff -r c1ed57cbfd66 -r 2a9204228f5e src/render/opengles2/SDL_render_gles2.c
>--- a/src/render/opengles2/SDL_render_gles2.c	Wed Jun 22 10:33:48 2011 +0000
>+++ b/src/render/opengles2/SDL_render_gles2.c	Sun Jul 03 18:58:20 2011 +0800
>@@ -122,6 +122,10 @@
>         SDL_bool tex_coords;
>     } current;
> 
>+#define SDL_PROC(ret,func,params) ret (APIENTRY *func) params;
>+#include "SDL_gles2funcs.h"
>+#undef SDL_PROC
>+
>     int shader_format_count;
>     GLenum *shader_formats;
>     GLES2_ShaderCache shader_cache;
>@@ -143,6 +147,26 @@
> 
> static SDL_GLContext SDL_CurrentContext = NULL;
> 
>+static int GLES2_LoadFunctions(GLES2_DriverContext * data)
>+{
>+#ifdef __SDL_NOGETPROCADDR__
>+#define SDL_PROC(ret,func,params) data->func=func;
>+#else
>+#define SDL_PROC(ret,func,params) \
>+    do { \
>+        data->func = SDL_GL_GetProcAddress(#func); \
>+        if ( ! data->func ) { \
>+            SDL_SetError("Couldn't load GLES2 function %s: %s\n", #func, SDL_GetError()); \
>+            return -1; \
>+        } \
>+    } while ( 0 );  
>+#endif /* _SDL_NOGETPROCADDR_ */
>+
>+#include "SDL_gles2funcs.h"
>+#undef SDL_PROC
>+    return 0;
>+}
>+
> static int
> GLES2_ActivateRenderer(SDL_Renderer * renderer)
> {
>@@ -181,7 +205,7 @@
>         return 0;
>     }
> 
>-    glViewport(renderer->viewport.x, renderer->viewport.y,
>+    rdata->glViewport(renderer->viewport.x, renderer->viewport.y,
>                renderer->viewport.w, renderer->viewport.h);
>     return 0;
> }
>@@ -199,11 +223,11 @@
> 
>         entry = rdata->program_cache.head;
>         while (entry) {
>-            glDeleteShader(entry->vertex_shader->id);
>-            glDeleteShader(entry->fragment_shader->id);
>+            rdata->glDeleteShader(entry->vertex_shader->id);
>+            rdata->glDeleteShader(entry->fragment_shader->id);
>             SDL_free(entry->vertex_shader);
>             SDL_free(entry->fragment_shader);
>-            glDeleteProgram(entry->id);
>+            rdata->glDeleteProgram(entry->id);
>             next = entry->next;
>             SDL_free(entry);
>             entry = next;
>@@ -253,6 +277,8 @@
> 
>     GLES2_ActivateRenderer(renderer);
> 
>+    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
>+
>     /* Determine the corresponding GLES texture format params */
>     switch (texture->format)
>     {
>@@ -292,19 +318,19 @@
>     }
> 
>     /* Allocate the texture */
>-    glGetError();
>-    glGenTextures(1, &tdata->texture);
>-    glActiveTexture(GL_TEXTURE0);
>-    glBindTexture(tdata->texture_type, tdata->texture);
>-    glTexParameteri(tdata->texture_type, GL_TEXTURE_MIN_FILTER, scaleMode);
>-    glTexParameteri(tdata->texture_type, GL_TEXTURE_MAG_FILTER, scaleMode);
>-    glTexParameteri(tdata->texture_type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
>-    glTexParameteri(tdata->texture_type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
>-    glTexImage2D(tdata->texture_type, 0, format, texture->w, texture->h, 0, format, type, NULL);
>-    if (glGetError() != GL_NO_ERROR)
>+    rdata->glGetError();
>+    rdata->glGenTextures(1, &tdata->texture);
>+    rdata->glActiveTexture(GL_TEXTURE0);
>+    rdata->glBindTexture(tdata->texture_type, tdata->texture);
>+    rdata->glTexParameteri(tdata->texture_type, GL_TEXTURE_MIN_FILTER, scaleMode);
>+    rdata->glTexParameteri(tdata->texture_type, GL_TEXTURE_MAG_FILTER, scaleMode);
>+    rdata->glTexParameteri(tdata->texture_type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
>+    rdata->glTexParameteri(tdata->texture_type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
>+    rdata->glTexImage2D(tdata->texture_type, 0, format, texture->w, texture->h, 0, format, type, NULL);
>+    if (rdata->glGetError() != GL_NO_ERROR)
>     {
>         SDL_SetError("Texture creation failed");
>-        glDeleteTextures(1, &tdata->texture);
>+        rdata->glDeleteTextures(1, &tdata->texture);
>         SDL_free(tdata);
>         return -1;
>     }
>@@ -319,10 +345,12 @@
> 
>     GLES2_ActivateRenderer(renderer);
> 
>+    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
>+
>     /* Destroy the texture */
>     if (tdata)
>     {
>-        glDeleteTextures(1, &tdata->texture);
>+        rdata->glDeleteTextures(1, &tdata->texture);
>         SDL_free(tdata->pixel_data);
>         SDL_free(tdata);
>         texture->driverdata = NULL;
>@@ -370,6 +398,8 @@
> 
>     GLES2_ActivateRenderer(renderer);
> 
>+    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
>+    
>     /* Bail out if we're supposed to update an empty rectangle */
>     if (rect->w <= 0 || rect->h <= 0)
>         return 0;
>@@ -396,11 +426,11 @@
>     }
> 
>     /* Create a texture subimage with the supplied data */
>-    glGetError();
>-    glActiveTexture(GL_TEXTURE0);
>-    glBindTexture(tdata->texture_type, tdata->texture);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
>-    glTexSubImage2D(tdata->texture_type,
>+    rdata->glGetError();
>+    rdata->glActiveTexture(GL_TEXTURE0);
>+    rdata->glBindTexture(tdata->texture_type, tdata->texture);
>+    rdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
>+    rdata->glTexSubImage2D(tdata->texture_type,
>                     0,
>                     rect->x,
>                     rect->y,
>@@ -413,7 +443,7 @@
>         SDL_free(blob);
>     }
> 
>-    if (glGetError() != GL_NO_ERROR)
>+    if (rdata->glGetError() != GL_NO_ERROR)
>     {
>         SDL_SetError("Failed to update texture");
>         return -1;
>@@ -481,33 +511,33 @@
>     entry->blend_mode = blendMode;
>     
>     /* Create the program and link it */
>-    glGetError();
>-    entry->id = glCreateProgram();
>-    glAttachShader(entry->id, vertex->id);
>-    glAttachShader(entry->id, fragment->id);
>-    glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_POSITION, "a_position");
>-    glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_TEXCOORD, "a_texCoord");
>-    glLinkProgram(entry->id);
>-    glGetProgramiv(entry->id, GL_LINK_STATUS, &linkSuccessful);
>-    if (glGetError() != GL_NO_ERROR || !linkSuccessful)
>+    rdata->glGetError();
>+    entry->id = rdata->glCreateProgram();
>+    rdata->glAttachShader(entry->id, vertex->id);
>+    rdata->glAttachShader(entry->id, fragment->id);
>+    rdata->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_POSITION, "a_position");
>+    rdata->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_TEXCOORD, "a_texCoord");
>+    rdata->glLinkProgram(entry->id);
>+    rdata->glGetProgramiv(entry->id, GL_LINK_STATUS, &linkSuccessful);
>+    if (rdata->glGetError() != GL_NO_ERROR || !linkSuccessful)
>     {
>         SDL_SetError("Failed to link shader program");
>-        glDeleteProgram(entry->id);
>+        rdata->glDeleteProgram(entry->id);
>         SDL_free(entry);
>         return NULL;
>     }
>     
>     /* Predetermine locations of uniform variables */
>     entry->uniform_locations[GLES2_UNIFORM_PROJECTION] =
>-        glGetUniformLocation(entry->id, "u_projection");
>+        rdata->glGetUniformLocation(entry->id, "u_projection");
>     entry->uniform_locations[GLES2_UNIFORM_TEXTURE] =
>-        glGetUniformLocation(entry->id, "u_texture");
>+        rdata->glGetUniformLocation(entry->id, "u_texture");
>     entry->uniform_locations[GLES2_UNIFORM_MODULATION] =
>-        glGetUniformLocation(entry->id, "u_modulation");
>+        rdata->glGetUniformLocation(entry->id, "u_modulation");
>     entry->uniform_locations[GLES2_UNIFORM_COLOR] =
>-        glGetUniformLocation(entry->id, "u_color");
>+        rdata->glGetUniformLocation(entry->id, "u_color");
>     entry->uniform_locations[GLES2_UNIFORM_COLORTABLE] =
>-        glGetUniformLocation(entry->id, "u_colorTable");
>+        rdata->glGetUniformLocation(entry->id, "u_colorTable");
> 
>     /* Cache the linked program */
>     if (rdata->program_cache.head)
>@@ -535,7 +565,7 @@
>         shaderEntry = rdata->program_cache.tail->fragment_shader;
>         if (--shaderEntry->references <= 0)
>             GLES2_EvictShader(renderer, shaderEntry);
>-        glDeleteProgram(rdata->program_cache.tail->id);
>+        rdata->glDeleteProgram(rdata->program_cache.tail->id);
>         rdata->program_cache.tail = rdata->program_cache.tail->prev;
>         SDL_free(rdata->program_cache.tail->next);
>         rdata->program_cache.tail->next = NULL;
>@@ -604,29 +634,29 @@
>     entry->instance = instance;
> 
>     /* Compile or load the selected shader instance */
>-    glGetError();
>-    entry->id = glCreateShader(instance->type);
>+    rdata->glGetError();
>+    entry->id = rdata->glCreateShader(instance->type);
>     if (instance->format == (GLenum)-1)
>     {
>-        glShaderSource(entry->id, 1, (const char **)&instance->data, NULL);
>-        glCompileShader(entry->id);
>-        glGetShaderiv(entry->id, GL_COMPILE_STATUS, &compileSuccessful);
>+        rdata->glShaderSource(entry->id, 1, (const char **)&instance->data, NULL);
>+        rdata->glCompileShader(entry->id);
>+        rdata->glGetShaderiv(entry->id, GL_COMPILE_STATUS, &compileSuccessful);
>     }
>     else
>     {
>-        glShaderBinary(1, &entry->id, instance->format, instance->data, instance->length);
>+        rdata->glShaderBinary(1, &entry->id, instance->format, instance->data, instance->length);
>         compileSuccessful = GL_TRUE;
>     }
>-    if (glGetError() != GL_NO_ERROR || !compileSuccessful)
>+    if (rdata->glGetError() != GL_NO_ERROR || !compileSuccessful)
>     {
>         char *info = NULL;
>         int length;
> 
>-        glGetShaderiv(entry->id, GL_INFO_LOG_LENGTH, &length);
>+        rdata->glGetShaderiv(entry->id, GL_INFO_LOG_LENGTH, &length);
>         if (length > 0) {
>             info = SDL_stack_alloc(char, length);
>             if (info) {
>-                glGetShaderInfoLog(entry->id, length, &length, info);
>+                rdata->glGetShaderInfoLog(entry->id, length, &length, info);
>             }
>         }
>         if (info) {
>@@ -635,7 +665,7 @@
>         } else {
>             SDL_SetError("Failed to load the shader");
>         }
>-        glDeleteShader(entry->id);
>+        rdata->glDeleteShader(entry->id);
>         SDL_free(entry);
>         return NULL;
>     }
>@@ -666,7 +696,7 @@
>     --rdata->shader_cache.count;
> 
>     /* Deallocate the shader */
>-    glDeleteShader(entry->id);
>+    rdata->glDeleteShader(entry->id);
>     SDL_free(entry);
> }
> 
>@@ -711,9 +741,9 @@
>         goto fault;
> 
>     /* Select that program in OpenGL */
>-    glGetError();
>-    glUseProgram(program->id);
>-    if (glGetError() != GL_NO_ERROR)
>+    rdata->glGetError();
>+    rdata->glUseProgram(program->id);
>+    if (rdata->glGetError() != GL_NO_ERROR)
>     {
>         SDL_SetError("Failed to select program");
>         goto fault;
>@@ -764,9 +794,9 @@
> 
>     /* Set the projection matrix */
>     locProjection = rdata->current_program->uniform_locations[GLES2_UNIFORM_PROJECTION];
>-    glGetError();
>-    glUniformMatrix4fv(locProjection, 1, GL_FALSE, (GLfloat *)projection);
>-    if (glGetError() != GL_NO_ERROR)
>+    rdata->glGetError();
>+    rdata->glUniformMatrix4fv(locProjection, 1, GL_FALSE, (GLfloat *)projection);
>+    if (rdata->glGetError() != GL_NO_ERROR)
>     {
>         SDL_SetError("Failed to set orthographic projection");
>         return -1;
>@@ -794,12 +824,14 @@
> {
>     GLES2_ActivateRenderer(renderer);
> 
>-    glClearColor((GLfloat) renderer->r * inv255f,
>+    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
>+    
>+    rdata->glClearColor((GLfloat) renderer->r * inv255f,
>                  (GLfloat) renderer->g * inv255f,
>                  (GLfloat) renderer->b * inv255f,
>                  (GLfloat) renderer->a * inv255f);
> 
>-    glClear(GL_COLOR_BUFFER_BIT);
>+    rdata->glClear(GL_COLOR_BUFFER_BIT);
> 
>     return 0;
> }
>@@ -811,19 +843,19 @@
>         switch (blendMode) {
>         default:
>         case SDL_BLENDMODE_NONE:
>-            glDisable(GL_BLEND);
>+            rdata->glDisable(GL_BLEND);
>             break;
>         case SDL_BLENDMODE_BLEND:
>-            glEnable(GL_BLEND);
>-            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
>+            rdata->glEnable(GL_BLEND);
>+            rdata->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
>             break;
>         case SDL_BLENDMODE_ADD:
>-            glEnable(GL_BLEND);
>-            glBlendFunc(GL_SRC_ALPHA, GL_ONE);
>+            rdata->glEnable(GL_BLEND);
>+            rdata->glBlendFunc(GL_SRC_ALPHA, GL_ONE);
>             break;
>         case SDL_BLENDMODE_MOD:
>-            glEnable(GL_BLEND);
>-            glBlendFunc(GL_ZERO, GL_SRC_COLOR);
>+            rdata->glEnable(GL_BLEND);
>+            rdata->glBlendFunc(GL_ZERO, GL_SRC_COLOR);
>             break;
>         }
>         rdata->current.blendMode = blendMode;
>@@ -835,9 +867,9 @@
> {
>     if (enabled != rdata->current.tex_coords) {
>         if (enabled) {
>-            glEnableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
>+            rdata->glEnableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
>         } else {
>-            glDisableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
>+            rdata->glDisableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
>         }
>         rdata->current.tex_coords = enabled;
>     }
>@@ -850,7 +882,7 @@
>     int blendMode = renderer->blendMode;
>     GLuint locColor;
> 
>-    glGetError();
>+    rdata->glGetError();
> 
>     GLES2_ActivateRenderer(renderer);
> 
>@@ -864,7 +896,7 @@
> 
>     /* Select the color to draw with */
>     locColor = rdata->current_program->uniform_locations[GLES2_UNIFORM_COLOR];
>-    glUniform4f(locColor,
>+    rdata->glUniform4f(locColor,
>                 renderer->r * inv255f,
>                 renderer->g * inv255f,
>                 renderer->b * inv255f,
>@@ -893,11 +925,11 @@
>         vertices[idx * 2] = x;
>         vertices[(idx * 2) + 1] = y;
>     }
>-    glGetError();
>-    glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
>-    glDrawArrays(GL_POINTS, 0, count);
>+    rdata->glGetError();
>+    rdata->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
>+    rdata->glDrawArrays(GL_POINTS, 0, count);
>     SDL_stack_free(vertices);
>-    if (glGetError() != GL_NO_ERROR)
>+    if (rdata->glGetError() != GL_NO_ERROR)
>     {
>         SDL_SetError("Failed to render lines");
>         return -1;
>@@ -926,11 +958,11 @@
>         vertices[idx * 2] = x;
>         vertices[(idx * 2) + 1] = y;
>     }
>-    glGetError();
>-    glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
>-    glDrawArrays(GL_LINE_STRIP, 0, count);
>+    rdata->glGetError();
>+    rdata->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
>+    rdata->glDrawArrays(GL_LINE_STRIP, 0, count);
>     SDL_stack_free(vertices);
>-    if (glGetError() != GL_NO_ERROR)
>+    if (rdata->glGetError() != GL_NO_ERROR)
>     {
>         SDL_SetError("Failed to render lines");
>         return -1;
>@@ -950,7 +982,7 @@
>     }
> 
>     /* Emit a line loop for each rectangle */
>-    glGetError();
>+    rdata->glGetError();
>     for (idx = 0; idx < count; ++idx) {
>         const SDL_Rect *rect = &rects[idx];
> 
>@@ -967,10 +999,10 @@
>         vertices[5] = yMax;
>         vertices[6] = xMax;
>         vertices[7] = yMax;
>-        glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
>-        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
>+        rdata->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
>+        rdata->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
>     }
>-    if (glGetError() != GL_NO_ERROR)
>+    if (rdata->glGetError() != GL_NO_ERROR)
>     {
>         SDL_SetError("Failed to render lines");
>         return -1;
>@@ -1001,14 +1033,14 @@
> 
>     /* Select the target texture */
>     locTexture = rdata->current_program->uniform_locations[GLES2_UNIFORM_TEXTURE];
>-    glGetError();
>-    glActiveTexture(GL_TEXTURE0);
>-    glBindTexture(tdata->texture_type, tdata->texture);
>-    glUniform1i(locTexture, 0);
>+    rdata->glGetError();
>+    rdata->glActiveTexture(GL_TEXTURE0);
>+    rdata->glBindTexture(tdata->texture_type, tdata->texture);
>+    rdata->glUniform1i(locTexture, 0);
> 
>     /* Configure color modulation */
>     locModulation = rdata->current_program->uniform_locations[GLES2_UNIFORM_MODULATION];
>-    glUniform4f(locModulation,
>+    rdata->glUniform4f(locModulation,
>                 texture->r * inv255f,
>                 texture->g * inv255f,
>                 texture->b * inv255f,
>@@ -1028,7 +1060,7 @@
>     vertices[5] = (GLfloat)(dstrect->y + dstrect->h);
>     vertices[6] = (GLfloat)(dstrect->x + dstrect->w);
>     vertices[7] = (GLfloat)(dstrect->y + dstrect->h);
>-    glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
>+    rdata->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
>     texCoords[0] = srcrect->x / (GLfloat)texture->w;
>     texCoords[1] = srcrect->y / (GLfloat)texture->h;
>     texCoords[2] = (srcrect->x + srcrect->w) / (GLfloat)texture->w;
>@@ -1037,9 +1069,9 @@
>     texCoords[5] = (srcrect->y + srcrect->h) / (GLfloat)texture->h;
>     texCoords[6] = (srcrect->x + srcrect->w) / (GLfloat)texture->w;
>     texCoords[7] = (srcrect->y + srcrect->h) / (GLfloat)texture->h;
>-    glVertexAttribPointer(GLES2_ATTRIBUTE_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 0, texCoords);
>-    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
>-    if (glGetError() != GL_NO_ERROR)
>+    rdata->glVertexAttribPointer(GLES2_ATTRIBUTE_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 0, texCoords);
>+    rdata->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
>+    if (rdata->glGetError() != GL_NO_ERROR)
>     {
>         SDL_SetError("Failed to render texture");
>         return -1;
>@@ -1076,8 +1108,8 @@
>     rdata->current.blendMode = -1;
>     rdata->current.tex_coords = SDL_FALSE;
> 
>-    glEnableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
>-    glDisableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
>+    rdata->glEnableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
>+    rdata->glDisableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
> }
> 
> static SDL_Renderer *
>@@ -1089,6 +1121,17 @@
> #ifndef ZUNE_HD
>     GLboolean hasCompiler;
> #endif
>+    Uint32 windowFlags;
>+    
>+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
>+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
>+    
>+    windowFlags = SDL_GetWindowFlags(window);
>+    if (!(windowFlags & SDL_WINDOW_OPENGL)) {
>+        if (SDL_RecreateWindow(window, windowFlags | SDL_WINDOW_OPENGL)) {
>+            return NULL;
>+        }
>+    }
> 
>     /* Create the renderer struct */
>     renderer = (SDL_Renderer *)SDL_calloc(1, sizeof(SDL_Renderer));
>@@ -1108,9 +1151,6 @@
>     renderer->driverdata = rdata;
> 
>     /* Create an OpenGL ES 2.0 context */
>-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
>-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
>-
>     rdata->context = SDL_GL_CreateContext(window);
>     if (!rdata->context)
>     {
>@@ -1122,6 +1162,11 @@
>         return NULL;
>     }
> 
>+    if (GLES2_LoadFunctions(rdata) < 0) {
>+        GLES2_DestroyRenderer(renderer);
>+        return NULL;
>+    }
>+
>     if (flags & SDL_RENDERER_PRESENTVSYNC) {
>         SDL_GL_SetSwapInterval(1);
>     } else {
>@@ -1131,14 +1176,18 @@
>         renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
>     }
> 
>+    /* Activate the context, so that queries work */
>+    SDL_GL_MakeCurrent(window, rdata->context);
>+
>+
>     /* Determine supported shader formats */
>     /* HACK: glGetInteger is broken on the Zune HD's compositor, so we just hardcode this */
>-    glGetError();
>+    rdata->glGetError();
> #ifdef ZUNE_HD
>     nFormats = 1;
> #else /* !ZUNE_HD */
>-    glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &nFormats);
>-    glGetBooleanv(GL_SHADER_COMPILER, &hasCompiler);
>+    rdata->glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &nFormats);
>+    rdata->glGetBooleanv(GL_SHADER_COMPILER, &hasCompiler);
>     if (hasCompiler)
>         ++nFormats;
> #endif /* ZUNE_HD */
>@@ -1153,8 +1202,8 @@
> #ifdef ZUNE_HD
>     rdata->shader_formats[0] = GL_NVIDIA_PLATFORM_BINARY_NV;
> #else /* !ZUNE_HD */
>-    glGetIntegerv(GL_SHADER_BINARY_FORMATS, (GLint *)rdata->shader_formats);
>-    if (glGetError() != GL_NO_ERROR)
>+    rdata->glGetIntegerv(GL_SHADER_BINARY_FORMATS, (GLint *)rdata->shader_formats);
>+    if (rdata->glGetError() != GL_NO_ERROR)
>     {
>         GLES2_DestroyRenderer(renderer);
>         SDL_SetError("Failed to query supported shader formats");
>diff -r c1ed57cbfd66 -r 2a9204228f5e src/video/SDL_sysvideo.h
>--- a/src/video/SDL_sysvideo.h	Wed Jun 22 10:33:48 2011 +0000
>+++ b/src/video/SDL_sysvideo.h	Sun Jul 03 18:58:20 2011 +0800
>@@ -281,7 +281,7 @@
>     void *driverdata;
>     struct SDL_GLDriverData *gl_data;
> 
>-#if SDL_VIDEO_DRIVER_PANDORA
>+#if SDL_VIDEO_OPENGL_ES
>     struct SDL_PrivateGLESData *gles_data;
> #endif
> 
>diff -r c1ed57cbfd66 -r 2a9204228f5e src/video/SDL_video.c
>--- a/src/video/SDL_video.c	Wed Jun 22 10:33:48 2011 +0000
>+++ b/src/video/SDL_video.c	Sun Jul 03 18:58:20 2011 +0800
>@@ -170,6 +170,11 @@
>         if (window) {
>             context = SDL_GL_CreateContext(window);
>             if (context) {
>+
>+                int status = SDL_GL_MakeCurrent(window, context);
>+                if (status < 0) {
>+                    return SDL_FALSE;
>+                }
>                 const GLubyte *(APIENTRY * glGetStringFunc) (GLenum);
>                 const char *vendor = NULL;
> 
>@@ -189,6 +194,9 @@
>         }
>         return hasAcceleratedOpenGL;
>     }
>+#elif SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2
>+    /* Let's be optimistic about this! */
>+    return SDL_TRUE;
> #else
>     return SDL_FALSE;
> #endif
>@@ -1143,7 +1151,7 @@
>     }
> 
>     /* Some platforms have OpenGL enabled by default */
>-#if (SDL_VIDEO_OPENGL && __MACOSX__) || SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2
>+#if (SDL_VIDEO_OPENGL && __MACOSX__)
>     flags |= SDL_WINDOW_OPENGL;
> #endif
>     if (flags & SDL_WINDOW_OPENGL) {
>diff -r c1ed57cbfd66 -r 2a9204228f5e src/video/x11/SDL_x11opengles.c
>--- a/src/video/x11/SDL_x11opengles.c	Wed Jun 22 10:33:48 2011 +0000
>+++ b/src/video/x11/SDL_x11opengles.c	Sun Jul 03 18:58:20 2011 +0800
>@@ -25,7 +25,10 @@
> #include "SDL_x11video.h"
> #include "SDL_x11opengles.h"
> 
>-#define DEFAULT_OPENGL	"/usr/lib/libGLES_CM.so"
>+#define DEFAULT_EGL "/usr/lib/libEGL.so"
>+#define DEFAULT_OGL_ES2 "/usr/lib/libGLESv2.so"
>+#define DEFAULT_OGL_ES_PVR "/usr/lib/libGLES_CM.so"
>+#define DEFAULT_OGL_ES "/usr/lib/libGLESv1_CM.so"
> 
> #define LOAD_FUNC(NAME) \
> 	*((void**)&_this->gles_data->NAME) = dlsym(handle, #NAME); \
>@@ -44,13 +47,15 @@
>     void *handle;
>     void *retval;
> 
>-    handle = _this->gl_config.dll_handle;
>+    handle = _this->gles_data->egl_dll_handle;
>     if (_this->gles_data->eglGetProcAddress) {
>         retval = _this->gles_data->eglGetProcAddress(proc);
>         if (retval) {
>             return retval;
>         }
>     }
>+    
>+    handle = _this->gl_config.dll_handle;
> #if defined(__OpenBSD__) && !defined(__ELF__)
> #undef dlsym(x,y);
> #endif
>@@ -70,6 +75,7 @@
>         _this->gles_data->eglTerminate(_this->gles_data->egl_display);
> 
>         dlclose(_this->gl_config.dll_handle);
>+        dlclose(_this->gles_data->egl_dll_handle);
> 
>         _this->gles_data->eglGetProcAddress = NULL;
>         _this->gles_data->eglChooseConfig = NULL;
>@@ -111,7 +117,7 @@
>         dlclose(handle);
>         path = getenv("SDL_VIDEO_GL_DRIVER");
>         if (path == NULL) {
>-            path = DEFAULT_OPENGL;
>+            path = DEFAULT_EGL;
>         }
>         handle = dlopen(path, dlopen_flags);
>     }
>@@ -137,6 +143,7 @@
>     LOAD_FUNC(eglDestroySurface);
>     LOAD_FUNC(eglMakeCurrent);
>     LOAD_FUNC(eglSwapBuffers);
>+    LOAD_FUNC(eglBindAPI);
> 
>     _this->gles_data->egl_display =
>         _this->gles_data->eglGetDisplay((NativeDisplayType) data->display);
>@@ -153,6 +160,29 @@
>         return -1;
>     }
> 
>+    _this->gles_data->egl_dll_handle = handle;
>+
>+    path = getenv("SDL_VIDEO_GL_DRIVER");
>+    handle = dlopen(path, dlopen_flags);
>+    if ((path == NULL) | (handle == NULL)) {
>+        if (_this->gl_config.major_version > 1) {
>+            path = DEFAULT_OGL_ES2;
>+            handle = dlopen(path, dlopen_flags);
>+        } else {
>+            path = DEFAULT_OGL_ES;
>+            handle = dlopen(path, dlopen_flags);
>+            if (handle == NULL) {
>+                path = DEFAULT_OGL_ES_PVR;
>+                handle = dlopen(path, dlopen_flags);
>+            }
>+        }
>+    }
>+
>+    if (handle == NULL) {
>+        SDL_SetError("Could not initialize OpenGL ES library");
>+        return -1;
>+    }
>+
>     _this->gl_config.dll_handle = handle;
>     _this->gl_config.driver_loaded = 1;
> 
>@@ -218,6 +248,13 @@
>         attribs[i++] = _this->gl_config.multisamplesamples;
>     }
> 
>+    attribs[i++] = EGL_RENDERABLE_TYPE;
>+    if (_this->gl_config.major_version == 2) {
>+        attribs[i++] = EGL_OPENGL_ES2_BIT;
>+    } else {
>+        attribs[i++] = EGL_OPENGL_ES_BIT;
>+    }
>+
>     attribs[i++] = EGL_NONE;
> 
>     if (_this->gles_data->eglChooseConfig(_this->gles_data->egl_display,
>@@ -261,16 +298,25 @@
> X11_GLES_CreateContext(_THIS, SDL_Window * window)
> {
>     int retval;
>+    EGLint context_attrib_list[] = {
>+        EGL_CONTEXT_CLIENT_VERSION,
>+        1,
>+        EGL_NONE
>+    };
>+
>     SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
>     Display *display = data->videodata->display;
> 
>     XSync(display, False);
> 
>+    if (_this->gl_config.major_version == 2) {
>+        context_attrib_list[1] = 2;
>+    }
> 
>     _this->gles_data->egl_context =
>         _this->gles_data->eglCreateContext(_this->gles_data->egl_display,
>                                            _this->gles_data->egl_config,
>-                                           EGL_NO_CONTEXT, NULL);
>+                                           EGL_NO_CONTEXT, context_attrib_list);
>     XSync(display, False);
> 
>     if (_this->gles_data->egl_context == EGL_NO_CONTEXT) {
>diff -r c1ed57cbfd66 -r 2a9204228f5e src/video/x11/SDL_x11opengles.h
>--- a/src/video/x11/SDL_x11opengles.h	Wed Jun 22 10:33:48 2011 +0000
>+++ b/src/video/x11/SDL_x11opengles.h	Sun Jul 03 18:58:20 2011 +0800
>@@ -32,6 +32,7 @@
> {
>     int egl_active;             /* to stop switching drivers while we have a valid context */
>     XVisualInfo *egl_visualinfo;
>+    void *egl_dll_handle;
>     EGLDisplay egl_display;
>     EGLContext egl_context;     /* Current GLES context */
>     EGLSurface egl_surface;
>@@ -72,6 +73,7 @@
>       EGLBoolean(*eglGetConfigAttrib) (EGLDisplay dpy, EGLConfig config,
>                                        EGLint attribute, EGLint * value);
> 
>+      EGLBoolean(*eglBindAPI) (EGLenum api);
> } SDL_PrivateGLESData;
> 
> /* OpenGLES functions */
>diff -r c1ed57cbfd66 -r 2a9204228f5e src/video/x11/SDL_x11video.c
>--- a/src/video/x11/SDL_x11video.c	Wed Jun 22 10:33:48 2011 +0000
>+++ b/src/video/x11/SDL_x11video.c	Sun Jul 03 18:58:20 2011 +0800
>@@ -34,7 +34,7 @@
> #include "SDL_x11shape.h"
> #include "SDL_x11touch.h" 
> 
>-#if SDL_VIDEO_DRIVER_PANDORA
>+#if SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2
> #include "SDL_x11opengles.h"
> #endif
> 
>@@ -110,7 +110,7 @@
>     }
>     SDL_free(data->windowlist);
>     SDL_free(device->driverdata);
>-#if SDL_VIDEO_DRIVER_PANDORA
>+#if SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2
>     SDL_free(device->gles_data);
> #endif
>     SDL_free(device);
>@@ -143,7 +143,7 @@
>     }
>     device->driverdata = data;
> 
>-#if SDL_VIDEO_DRIVER_PANDORA
>+#if SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2
>     device->gles_data = (struct SDL_PrivateGLESData *) SDL_calloc(1, sizeof(SDL_PrivateGLESData));
>     if (!device->gles_data) {
>         SDL_OutOfMemory();
>@@ -226,7 +226,7 @@
>     device->GL_SwapWindow = X11_GL_SwapWindow;
>     device->GL_DeleteContext = X11_GL_DeleteContext;
> #endif
>-#if SDL_VIDEO_DRIVER_PANDORA
>+#if SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2
>     device->GL_LoadLibrary = X11_GLES_LoadLibrary;
>     device->GL_GetProcAddress = X11_GLES_GetProcAddress;
>     device->GL_UnloadLibrary = X11_GLES_UnloadLibrary;
>diff -r c1ed57cbfd66 -r 2a9204228f5e src/video/x11/SDL_x11window.c
>--- a/src/video/x11/SDL_x11window.c	Wed Jun 22 10:33:48 2011 +0000
>+++ b/src/video/x11/SDL_x11window.c	Sun Jul 03 18:58:20 2011 +0800
>@@ -31,7 +31,7 @@
> #include "SDL_x11mouse.h"
> #include "SDL_x11shape.h"
> 
>-#ifdef SDL_VIDEO_DRIVER_PANDORA
>+#if SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2
> #include "SDL_x11opengles.h"
> #endif
> 
>@@ -297,7 +297,7 @@
>         XFree(vinfo);
>     } else
> #endif
>-#ifdef SDL_VIDEO_DRIVER_PANDORA
>+#if SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2
>     if (window->flags & SDL_WINDOW_OPENGL) {
>         XVisualInfo *vinfo;
> 
>@@ -410,17 +410,19 @@
>         SDL_SetError("Couldn't create window");
>         return -1;
>     }
>-#if SDL_VIDEO_DRIVER_PANDORA
>-    /* Create the GLES window surface */
>-    _this->gles_data->egl_surface =
>-        _this->gles_data->eglCreateWindowSurface(_this->gles_data->
>+#if SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2
>+    if (window->flags & SDL_WINDOW_OPENGL) {
>+        /* Create the GLES window surface */
>+        _this->gles_data->egl_surface =
>+            _this->gles_data->eglCreateWindowSurface(_this->gles_data->
>                                                  egl_display,
>                                                  _this->gles_data->egl_config,
>                                                  (NativeWindowType) w, NULL);
> 
>-    if (_this->gles_data->egl_surface == EGL_NO_SURFACE) {
>-        SDL_SetError("Could not create GLES window surface");
>-        return -1;
>+        if (_this->gles_data->egl_surface == EGL_NO_SURFACE) {
>+            SDL_SetError("Could not create GLES window surface");
>+            return -1;
>+        }
>     }
> #endif
> 
>diff -r c1ed57cbfd66 -r 2a9204228f5e test/configure.in
>--- a/test/configure.in	Wed Jun 22 10:33:48 2011 +0000
>+++ b/test/configure.in	Sun Jul 03 18:58:20 2011 +0800
>@@ -103,12 +103,10 @@
> AC_MSG_CHECKING(for OpenGL ES support)
> have_opengles=no
> AC_TRY_COMPILE([
>- #if defined (__QNXNTO__)
>-    #include <GLES/gl.h>
>- #elif defined (__IPHONEOS__)
>+ #if defined (__IPHONEOS__)
>     #include <OpenGLES/ES1/gl.h>
>  #else
>-    #error "No OpenGL ES support"
>+    #include <GLES/gl.h>
>  #endif /* __QNXNTO__ */
> ],[
> ],[
>@@ -116,12 +114,13 @@
> ])
> AC_MSG_RESULT($have_opengles)
> 
>-if test x$have_opengl = xyes; then
>+GLLIB=""
>+if test x$have_opengles = xyes; then
>+    CFLAGS="$CFLAGS -DHAVE_OPENGLES"
>+    GLLIB="$XPATH -lGLESv1_CM"
>+elif test x$have_opengl = xyes; then
>     CFLAGS="$CFLAGS -DHAVE_OPENGL"
>     GLLIB="$XPATH $SYS_GL_LIBS"
>-elif test x$have_opengles = xyes; then
>-    CFLAGS="$CFLAGS -DHAVE_OPENGLES"
>-    GLLIB="$XPATH $SYS_GL_LIBS"
> else
>     GLLIB=""
> fi

Actions: View | Diff

Attachments on bug 1242: 644 | 764

We are currently migrating Bugzilla to GitHub issues.Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.