Removed the OpenGL ES 1.0 2D render implementation

In SDL3 we plan to make more use of shaders in the 2D render API, and this minimizes the number of platforms we have to consider for new features. OpenGL ES 2.0 or newer is supported on all modern iOS and Android devices.

CMakeLists.txt

@@ -1293,7 +1293,6 @@ if(ANDROID)
       set(SDL_VIDEO_OPENGL_EGL 1)
       set(HAVE_OPENGLES TRUE)
       set(SDL_VIDEO_OPENGL_ES 1)
-      set(SDL_VIDEO_RENDER_OGL_ES 1)
       set(SDL_VIDEO_OPENGL_ES2 1)
       set(SDL_VIDEO_RENDER_OGL_ES2 1)
 
@@ -2165,7 +2164,6 @@ elseif(APPLE)
       if(IOS OR TVOS)
         set(SDL_FRAMEWORK_OPENGLES 1)
         set(SDL_VIDEO_OPENGL_ES 1)
-        set(SDL_VIDEO_RENDER_OGL_ES 1)
       else()
         set(SDL_VIDEO_OPENGL_EGL 1)
       endif()
@@ -2481,7 +2479,6 @@ elseif(VITA)
         set(SDL_VIDEO_OPENGL_EGL 1)
         set(HAVE_OPENGLES TRUE)
         set(SDL_VIDEO_OPENGL_ES 1)
-        set(SDL_VIDEO_RENDER_OGL_ES 1)
         set(SDL_VIDEO_OPENGL_ES2 1)
         set(SDL_VIDEO_RENDER_OGL_ES2 1)
 

cmake/sdlchecks.cmake

@@ -710,7 +710,6 @@ macro(CheckOpenGLES)
     if(HAVE_OPENGLES_V1)
         set(HAVE_OPENGLES TRUE)
         set(SDL_VIDEO_OPENGL_ES 1)
-        set(SDL_VIDEO_RENDER_OGL_ES 1)
     endif()
     check_c_source_compiles("
         #include <GLES2/gl2.h>

include/build_config/SDL_build_config.h.cmake

@@ -435,7 +435,6 @@
 #cmakedefine SDL_VIDEO_RENDER_D3D11 @SDL_VIDEO_RENDER_D3D11@
 #cmakedefine SDL_VIDEO_RENDER_D3D12 @SDL_VIDEO_RENDER_D3D12@
 #cmakedefine SDL_VIDEO_RENDER_OGL @SDL_VIDEO_RENDER_OGL@
-#cmakedefine SDL_VIDEO_RENDER_OGL_ES @SDL_VIDEO_RENDER_OGL_ES@
 #cmakedefine SDL_VIDEO_RENDER_OGL_ES2 @SDL_VIDEO_RENDER_OGL_ES2@
 #cmakedefine SDL_VIDEO_RENDER_METAL @SDL_VIDEO_RENDER_METAL@
 #cmakedefine SDL_VIDEO_RENDER_VITA_GXM @SDL_VIDEO_RENDER_VITA_GXM@

include/build_config/SDL_build_config_android.h

@@ -172,7 +172,6 @@
 #define SDL_VIDEO_OPENGL_ES 1
 #define SDL_VIDEO_OPENGL_ES2 1
 #define SDL_VIDEO_OPENGL_EGL 1
-#define SDL_VIDEO_RENDER_OGL_ES 1
 #define SDL_VIDEO_RENDER_OGL_ES2    1
 
 /* Enable Vulkan support */

include/build_config/SDL_build_config_ios.h

@@ -174,7 +174,6 @@
 #if !TARGET_OS_MACCATALYST
 #define SDL_VIDEO_OPENGL_ES2 1
 #define SDL_VIDEO_OPENGL_ES 1
-#define SDL_VIDEO_RENDER_OGL_ES 1
 #define SDL_VIDEO_RENDER_OGL_ES2    1
 #endif
 

src/render/SDL_render.c

@@ -106,9 +106,6 @@ static const SDL_RenderDriver *render_drivers[] = {
 #if SDL_VIDEO_RENDER_OGL_ES2
     &GLES2_RenderDriver,
 #endif
-#if SDL_VIDEO_RENDER_OGL_ES
-    &GLES_RenderDriver,
-#endif
 #if SDL_VIDEO_RENDER_PS2 && !SDL_RENDER_DISABLED
     &PS2_RenderDriver,
 #endif

src/render/SDL_sysrender.h

@@ -297,7 +297,6 @@ extern SDL_RenderDriver D3D11_RenderDriver;
 extern SDL_RenderDriver D3D12_RenderDriver;
 extern SDL_RenderDriver GL_RenderDriver;
 extern SDL_RenderDriver GLES2_RenderDriver;
-extern SDL_RenderDriver GLES_RenderDriver;
 extern SDL_RenderDriver METAL_RenderDriver;
 extern SDL_RenderDriver PS2_RenderDriver;
 extern SDL_RenderDriver PSP_RenderDriver;

src/render/opengles/SDL_glesfuncs.h

@@ -1,62 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  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.
-*/
-
-SDL_PROC(void, glBindTexture, (GLenum, GLuint))
-SDL_PROC(void, glBlendFunc, (GLenum, GLenum))
-SDL_PROC_OES(void, glBlendEquationOES, (GLenum))
-SDL_PROC_OES(void, glBlendEquationSeparateOES, (GLenum, GLenum))
-SDL_PROC_OES(void, glBlendFuncSeparateOES, (GLenum, GLenum, 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, glColorPointer, (GLint, GLenum, GLsizei, const GLvoid *))
-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_OES(void, glDrawTexfOES, (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat))
-SDL_PROC(void, glEnable, (GLenum))
-SDL_PROC(void, glEnableClientState, (GLenum))
-SDL_PROC(void, glFinish, (void))
-SDL_PROC_OES(void, glGenFramebuffersOES, (GLsizei, GLuint *))
-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, glReadPixels, (GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
-SDL_PROC(void, glScissor, (GLint, GLint, GLsizei, GLsizei))
-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))
-SDL_PROC_OES(void, glBindFramebufferOES, (GLenum, GLuint))
-SDL_PROC_OES(void, glFramebufferTexture2DOES, (GLenum, GLenum, GLenum, GLuint, GLint))
-SDL_PROC_OES(GLenum, glCheckFramebufferStatusOES, (GLenum))
-SDL_PROC_OES(void, glDeleteFramebuffersOES, (GLsizei, const GLuint *))
-
-/* vi: set ts=4 sw=4 expandtab: */

src/render/opengles/SDL_render_gles.c

@@ -1,1191 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  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 "SDL_internal.h"
-
-#if SDL_VIDEO_RENDER_OGL_ES && !SDL_RENDER_DISABLED
-
-#include "../../video/SDL_sysvideo.h" /* For SDL_GL_SwapWindowWithResult */
-#include <SDL3/SDL_opengles.h>
-#include "../SDL_sysrender.h"
-#include "../../SDL_utils_c.h"
-
-/* To prevent unnecessary window recreation,
- * these should match the defaults selected in SDL_GL_ResetAttributes
- */
-
-#define RENDERER_CONTEXT_MAJOR 1
-#define RENDERER_CONTEXT_MINOR 1
-
-/* OpenGL ES 1.1 renderer implementation, based on the OpenGL renderer */
-
-/* Used to re-create the window with OpenGL ES capability */
-extern int SDL_RecreateWindow(SDL_Window *window, Uint32 flags);
-
-static const float inv255f = 1.0f / 255.0f;
-
-typedef struct GLES_FBOList GLES_FBOList;
-
-struct GLES_FBOList
-{
-    Uint32 w, h;
-    GLuint FBO;
-    GLES_FBOList *next;
-};
-
-typedef struct
-{
-    SDL_Rect viewport;
-    SDL_bool viewport_dirty;
-    SDL_Texture *texture;
-    SDL_Texture *target;
-    int drawablew;
-    int drawableh;
-    SDL_BlendMode blend;
-    SDL_bool cliprect_enabled_dirty;
-    SDL_bool cliprect_enabled;
-    SDL_bool cliprect_dirty;
-    SDL_Rect cliprect;
-    SDL_bool texturing;
-    Uint32 color;
-    Uint32 clear_color;
-} GLES_DrawStateCache;
-
-typedef struct
-{
-    SDL_GLContext context;
-
-#define SDL_PROC(ret, func, params) ret(APIENTRY *func) params;
-#define SDL_PROC_OES                SDL_PROC
-#include "SDL_glesfuncs.h"
-#undef SDL_PROC
-#undef SDL_PROC_OES
-    SDL_bool GL_OES_framebuffer_object_supported;
-    GLES_FBOList *framebuffers;
-    GLuint window_framebuffer;
-
-    SDL_bool GL_OES_blend_func_separate_supported;
-    SDL_bool GL_OES_blend_equation_separate_supported;
-    SDL_bool GL_OES_blend_subtract_supported;
-
-    GLES_DrawStateCache drawstate;
-} GLES_RenderData;
-
-typedef struct
-{
-    GLuint texture;
-    GLenum type;
-    GLfloat texw;
-    GLfloat texh;
-    GLenum format;
-    GLenum formattype;
-    void *pixels;
-    int pitch;
-    GLES_FBOList *fbo;
-} GLES_TextureData;
-
-static int GLES_SetError(const char *prefix, GLenum result)
-{
-    const char *error;
-
-    switch (result) {
-    case GL_NO_ERROR:
-        error = "GL_NO_ERROR";
-        break;
-    case GL_INVALID_ENUM:
-        error = "GL_INVALID_ENUM";
-        break;
-    case GL_INVALID_VALUE:
-        error = "GL_INVALID_VALUE";
-        break;
-    case GL_INVALID_OPERATION:
-        error = "GL_INVALID_OPERATION";
-        break;
-    case GL_STACK_OVERFLOW:
-        error = "GL_STACK_OVERFLOW";
-        break;
-    case GL_STACK_UNDERFLOW:
-        error = "GL_STACK_UNDERFLOW";
-        break;
-    case GL_OUT_OF_MEMORY:
-        error = "GL_OUT_OF_MEMORY";
-        break;
-    default:
-        error = "UNKNOWN";
-        break;
-    }
-    return SDL_SetError("%s: %s", prefix, error);
-}
-
-static int GLES_LoadFunctions(GLES_RenderData *data)
-{
-#if SDL_VIDEO_DRIVER_UIKIT
-#define __SDL_NOGETPROCADDR__
-#elif SDL_VIDEO_DRIVER_ANDROID
-#define __SDL_NOGETPROCADDR__
-#endif
-
-#ifdef __SDL_NOGETPROCADDR__
-#define SDL_PROC(ret, func, params)     data->func = func;
-#define SDL_PROC_OES(ret, func, params) data->func = func;
-#else
-#define SDL_PROC(ret, func, params)                                                           \
-    do {                                                                                      \
-        data->func = SDL_GL_GetProcAddress(#func);                                            \
-        if (!data->func) {                                                                    \
-            return SDL_SetError("Couldn't load GLES function %s: %s", #func, SDL_GetError()); \
-        }                                                                                     \
-    } while (0);
-#define SDL_PROC_OES(ret, func, params)            \
-    do {                                           \
-        data->func = SDL_GL_GetProcAddress(#func); \
-    } while (0);
-#endif /* __SDL_NOGETPROCADDR__ */
-
-#include "SDL_glesfuncs.h"
-#undef SDL_PROC
-#undef SDL_PROC_OES
-    return 0;
-}
-
-static GLES_FBOList *GLES_GetFBO(GLES_RenderData *data, Uint32 w, Uint32 h)
-{
-    GLES_FBOList *result = data->framebuffers;
-    while ((result) && ((result->w != w) || (result->h != h))) {
-        result = result->next;
-    }
-    if (result == NULL) {
-        result = SDL_malloc(sizeof(GLES_FBOList));
-        result->w = w;
-        result->h = h;
-        data->glGenFramebuffersOES(1, &result->FBO);
-        result->next = data->framebuffers;
-        data->framebuffers = result;
-    }
-    return result;
-}
-
-static int GLES_ActivateRenderer(SDL_Renderer *renderer)
-{
-    GLES_RenderData *data = (GLES_RenderData *)renderer->driverdata;
-
-    if (SDL_GL_GetCurrentContext() != data->context) {
-        if (SDL_GL_MakeCurrent(renderer->window, data->context) < 0) {
-            return -1;
-        }
-    }
-
-    return 0;
-}
-
-static void GLES_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
-{
-    GLES_RenderData *data = (GLES_RenderData *)renderer->driverdata;
-
-    if (event->event == SDL_WINDOWEVENT_MINIMIZED) {
-        /* According to Apple documentation, we need to finish drawing NOW! */
-        data->glFinish();
-    }
-}
-
-static int GLES_GetOutputSize(SDL_Renderer *renderer, int *w, int *h)
-{
-    SDL_GL_GetDrawableSize(renderer->window, w, h);
-    return 0;
-}
-
-static GLenum GetBlendFunc(SDL_BlendFactor factor)
-{
-    switch (factor) {
-    case SDL_BLENDFACTOR_ZERO:
-        return GL_ZERO;
-    case SDL_BLENDFACTOR_ONE:
-        return GL_ONE;
-    case SDL_BLENDFACTOR_SRC_COLOR:
-        return GL_SRC_COLOR;
-    case SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR:
-        return GL_ONE_MINUS_SRC_COLOR;
-    case SDL_BLENDFACTOR_SRC_ALPHA:
-        return GL_SRC_ALPHA;
-    case SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA:
-        return GL_ONE_MINUS_SRC_ALPHA;
-    case SDL_BLENDFACTOR_DST_COLOR:
-        return GL_DST_COLOR;
-    case SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR:
-        return GL_ONE_MINUS_DST_COLOR;
-    case SDL_BLENDFACTOR_DST_ALPHA:
-        return GL_DST_ALPHA;
-    case SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA:
-        return GL_ONE_MINUS_DST_ALPHA;
-    default:
-        return GL_INVALID_ENUM;
-    }
-}
-
-static GLenum GetBlendEquation(SDL_BlendOperation operation)
-{
-    switch (operation) {
-    case SDL_BLENDOPERATION_ADD:
-        return GL_FUNC_ADD_OES;
-    case SDL_BLENDOPERATION_SUBTRACT:
-        return GL_FUNC_SUBTRACT_OES;
-    case SDL_BLENDOPERATION_REV_SUBTRACT:
-        return GL_FUNC_REVERSE_SUBTRACT_OES;
-    default:
-        return GL_INVALID_ENUM;
-    }
-}
-
-static SDL_bool GLES_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
-{
-    GLES_RenderData *data = (GLES_RenderData *)renderer->driverdata;
-    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
-    SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
-    SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode);
-    SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode);
-    SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode);
-    SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);
-
-    if (GetBlendFunc(srcColorFactor) == GL_INVALID_ENUM ||
-        GetBlendFunc(srcAlphaFactor) == GL_INVALID_ENUM ||
-        GetBlendEquation(colorOperation) == GL_INVALID_ENUM ||
-        GetBlendFunc(dstColorFactor) == GL_INVALID_ENUM ||
-        GetBlendFunc(dstAlphaFactor) == GL_INVALID_ENUM ||
-        GetBlendEquation(alphaOperation) == GL_INVALID_ENUM) {
-        return SDL_FALSE;
-    }
-    if ((srcColorFactor != srcAlphaFactor || dstColorFactor != dstAlphaFactor) && !data->GL_OES_blend_func_separate_supported) {
-        return SDL_FALSE;
-    }
-    if (colorOperation != alphaOperation && !data->GL_OES_blend_equation_separate_supported) {
-        return SDL_FALSE;
-    }
-    if (colorOperation != SDL_BLENDOPERATION_ADD && !data->GL_OES_blend_subtract_supported) {
-        return SDL_FALSE;
-    }
-    return SDL_TRUE;
-}
-
-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;
-    int texture_w, texture_h;
-    GLenum scaleMode;
-    GLenum result;
-
-    GLES_ActivateRenderer(renderer);
-
-    switch (texture->format) {
-    case SDL_PIXELFORMAT_ABGR8888:
-        internalFormat = GL_RGBA;
-        format = GL_RGBA;
-        type = GL_UNSIGNED_BYTE;
-        break;
-    default:
-        return SDL_SetError("Texture format not supported");
-    }
-
-    data = (GLES_TextureData *)SDL_calloc(1, sizeof(*data));
-    if (data == NULL) {
-        return SDL_OutOfMemory();
-    }
-
-    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
-        data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
-        data->pixels = SDL_calloc(1, texture->h * data->pitch);
-        if (!data->pixels) {
-            SDL_free(data);
-            return SDL_OutOfMemory();
-        }
-    }
-
-    if (texture->access == SDL_TEXTUREACCESS_TARGET) {
-        if (!renderdata->GL_OES_framebuffer_object_supported) {
-            SDL_free(data);
-            return SDL_SetError("GL_OES_framebuffer_object not supported");
-        }
-        data->fbo = GLES_GetFBO(renderer->driverdata, texture->w, texture->h);
-    } else {
-        data->fbo = NULL;
-    }
-
-    renderdata->glGetError();
-    renderdata->glEnable(GL_TEXTURE_2D);
-    renderdata->glGenTextures(1, &data->texture);
-    result = renderdata->glGetError();
-    if (result != GL_NO_ERROR) {
-        if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
-            SDL_free(data->pixels);
-        }
-        SDL_free(data);
-        return GLES_SetError("glGenTextures()", result);
-    }
-
-    data->type = GL_TEXTURE_2D;
-    /* no NPOV textures allowed in OpenGL ES (yet) */
-    texture_w = SDL_powerof2(texture->w);
-    texture_h = SDL_powerof2(texture->h);
-    data->texw = (GLfloat)texture->w / texture_w;
-    data->texh = (GLfloat)texture->h / texture_h;
-
-    data->format = format;
-    data->formattype = type;
-    scaleMode = (texture->scaleMode == SDL_ScaleModeNearest) ? GL_NEAREST : GL_LINEAR;
-    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);
-
-    renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w,
-                             texture_h, 0, format, type, NULL);
-    renderdata->glDisable(GL_TEXTURE_2D);
-    renderdata->drawstate.texture = texture;
-    renderdata->drawstate.texturing = SDL_FALSE;
-
-    result = renderdata->glGetError();
-    if (result != GL_NO_ERROR) {
-        if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
-            SDL_free(data->pixels);
-        }
-        SDL_free(data);
-        return GLES_SetError("glTexImage2D()", result);
-    }
-
-    texture->driverdata = data;
-    return 0;
-}
-
-static int 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;
-    int srcPitch;
-    int y;
-
-    GLES_ActivateRenderer(renderer);
-
-    /* Bail out if we're supposed to update an empty rectangle */
-    if (rect->w <= 0 || rect->h <= 0) {
-        return 0;
-    }
-
-    /* Reformat the texture data into a tightly packed array */
-    srcPitch = rect->w * SDL_BYTESPERPIXEL(texture->format);
-    src = (Uint8 *)pixels;
-    if (pitch != srcPitch) {
-        blob = (Uint8 *)SDL_malloc(srcPitch * rect->h);
-        if (blob == NULL) {
-            return SDL_OutOfMemory();
-        }
-        src = blob;
-        for (y = 0; y < rect->h; ++y) {
-            SDL_memcpy(src, pixels, srcPitch);
-            src += srcPitch;
-            pixels = (Uint8 *)pixels + pitch;
-        }
-        src = blob;
-    }
-
-    /* Create a texture subimage with the supplied data */
-    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,
-                                rect->w,
-                                rect->h,
-                                data->format,
-                                data->formattype,
-                                src);
-    renderdata->glDisable(data->type);
-    SDL_free(blob);
-
-    renderdata->drawstate.texture = texture;
-    renderdata->drawstate.texturing = SDL_FALSE;
-
-    if (renderdata->glGetError() != GL_NO_ERROR) {
-        return SDL_SetError("Failed to update texture");
-    }
-    return 0;
-}
-
-static int GLES_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
-                            const SDL_Rect *rect, void **pixels, int *pitch)
-{
-    GLES_TextureData *data = (GLES_TextureData *)texture->driverdata;
-
-    *pixels =
-        (void *)((Uint8 *)data->pixels + rect->y * data->pitch +
-                 rect->x * SDL_BYTESPERPIXEL(texture->format));
-    *pitch = data->pitch;
-    return 0;
-}
-
-static void GLES_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
-{
-    GLES_TextureData *data = (GLES_TextureData *)texture->driverdata;
-    SDL_Rect rect;
-
-    /* We do whole texture updates, at least for now */
-    rect.x = 0;
-    rect.y = 0;
-    rect.w = texture->w;
-    rect.h = texture->h;
-    GLES_UpdateTexture(renderer, texture, &rect, data->pixels, data->pitch);
-}
-
-static void GLES_SetTextureScaleMode(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode)
-{
-    GLES_RenderData *renderdata = (GLES_RenderData *)renderer->driverdata;
-    GLES_TextureData *data = (GLES_TextureData *)texture->driverdata;
-    GLenum glScaleMode = (scaleMode == SDL_ScaleModeNearest) ? GL_NEAREST : GL_LINEAR;
-
-    renderdata->glBindTexture(data->type, data->texture);
-    renderdata->glTexParameteri(data->type, GL_TEXTURE_MIN_FILTER, glScaleMode);
-    renderdata->glTexParameteri(data->type, GL_TEXTURE_MAG_FILTER, glScaleMode);
-}
-
-static int GLES_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
-{
-    GLES_RenderData *data = (GLES_RenderData *)renderer->driverdata;
-    GLES_TextureData *texturedata = NULL;
-    GLenum status;
-
-    if (!data->GL_OES_framebuffer_object_supported) {
-        return SDL_SetError("Can't enable render target support in this renderer");
-    }
-
-    data->drawstate.viewport_dirty = SDL_TRUE;
-
-    if (texture == NULL) {
-        data->glBindFramebufferOES(GL_FRAMEBUFFER_OES, data->window_framebuffer);
-        return 0;
-    }
-
-    texturedata = (GLES_TextureData *)texture->driverdata;
-    data->glBindFramebufferOES(GL_FRAMEBUFFER_OES, texturedata->fbo->FBO);
-    /* TODO: check if texture pixel format allows this operation */
-    data->glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, texturedata->type, texturedata->texture, 0);
-    /* Check FBO status */
-    status = data->glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES);
-    if (status != GL_FRAMEBUFFER_COMPLETE_OES) {
-        return SDL_SetError("glFramebufferTexture2DOES() failed");
-    }
-    return 0;
-}
-
-static int GLES_QueueSetViewport(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
-{
-    return 0; /* nothing to do in this backend. */
-}
-
-static int GLES_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
-{
-    GLfloat *verts = (GLfloat *)SDL_AllocateRenderVertices(renderer, count * 2 * sizeof(GLfloat), 0, &cmd->data.draw.first);
-    int i;
-
-    if (verts == NULL) {
-        return -1;
-    }
-
-    cmd->data.draw.count = count;
-    for (i = 0; i < count; i++) {
-        *(verts++) = 0.5f + points[i].x;
-        *(verts++) = 0.5f + points[i].y;
-    }
-
-    return 0;
-}
-
-static int GLES_QueueDrawLines(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
-{
-    int i;
-    GLfloat prevx, prevy;
-    const size_t vertlen = (sizeof(GLfloat) * 2) * count;
-    GLfloat *verts = (GLfloat *)SDL_AllocateRenderVertices(renderer, vertlen, 0, &cmd->data.draw.first);
-
-    if (verts == NULL) {
-        return -1;
-    }
-    cmd->data.draw.count = count;
-
-    /* 0.5f offset to hit the center of the pixel. */
-    prevx = 0.5f + points->x;
-    prevy = 0.5f + points->y;
-    *(verts++) = prevx;
-    *(verts++) = prevy;
-
-    /* bump the end of each line segment out a quarter of a pixel, to provoke
-       the diamond-exit rule. Without this, you won't just drop the last
-       pixel of the last line segment, but you might also drop pixels at the
-       edge of any given line segment along the way too. */
-    for (i = 1; i < count; i++) {
-        const GLfloat xstart = prevx;
-        const GLfloat ystart = prevy;
-        const GLfloat xend = points[i].x + 0.5f; /* 0.5f to hit pixel center. */
-        const GLfloat yend = points[i].y + 0.5f;
-        /* bump a little in the direction we are moving in. */
-        const GLfloat deltax = xend - xstart;
-        const GLfloat deltay = yend - ystart;
-        const GLfloat angle = SDL_atan2f(deltay, deltax);
-        prevx = xend + (SDL_cosf(angle) * 0.25f);
-        prevy = yend + (SDL_sinf(angle) * 0.25f);
-        *(verts++) = prevx;
-        *(verts++) = prevy;
-    }
-
-    return 0;
-}
-
-static int GLES_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
-                              const float *xy, int xy_stride, const SDL_Color *color, int color_stride, const float *uv, int uv_stride,
-                              int num_vertices, const void *indices, int num_indices, int size_indices,
-                              float scale_x, float scale_y)
-{
-    GLES_TextureData *texturedata = NULL;
-    int i;
-    int count = indices ? num_indices : num_vertices;
-    GLfloat *verts;
-    int sz = 2 + 4 + (texture ? 2 : 0);
-
-    verts = (GLfloat *)SDL_AllocateRenderVertices(renderer, count * sz * sizeof(GLfloat), 0, &cmd->data.draw.first);
-    if (verts == NULL) {
-        return -1;
-    }
-
-    if (texture) {
-        texturedata = (GLES_TextureData *)texture->driverdata;
-    }
-
-    cmd->data.draw.count = count;
-    size_indices = indices ? size_indices : 0;
-
-    for (i = 0; i < count; i++) {
-        int j;
-        float *xy_;
-        SDL_Color col_;
-        if (size_indices == 4) {
-            j = ((const Uint32 *)indices)[i];
-        } else if (size_indices == 2) {
-            j = ((const Uint16 *)indices)[i];
-        } else if (size_indices == 1) {
-            j = ((const Uint8 *)indices)[i];
-        } else {
-            j = i;
-        }
-
-        xy_ = (float *)((char *)xy + j * xy_stride);
-        col_ = *(SDL_Color *)((char *)color + j * color_stride);
-
-        *(verts++) = xy_[0] * scale_x;
-        *(verts++) = xy_[1] * scale_y;
-
-        *(verts++) = col_.r * inv255f;
-        *(verts++) = col_.g * inv255f;
-        *(verts++) = col_.b * inv255f;
-        *(verts++) = col_.a * inv255f;
-
-        if (texture) {
-            float *uv_ = (float *)((char *)uv + j * uv_stride);
-            *(verts++) = uv_[0] * texturedata->texw;
-            *(verts++) = uv_[1] * texturedata->texh;
-        }
-    }
-    return 0;
-}
-
-static void SetDrawState(GLES_RenderData *data, const SDL_RenderCommand *cmd)
-{
-    const SDL_BlendMode blend = cmd->data.draw.blend;
-    const Uint8 r = cmd->data.draw.r;
-    const Uint8 g = cmd->data.draw.g;
-    const Uint8 b = cmd->data.draw.b;
-    const Uint8 a = cmd->data.draw.a;
-    const Uint32 color = (((Uint32)a << 24) | (r << 16) | (g << 8) | b);
-
-    if (color != data->drawstate.color) {
-        const GLfloat fr = ((GLfloat)r) * inv255f;
-        const GLfloat fg = ((GLfloat)g) * inv255f;
-        const GLfloat fb = ((GLfloat)b) * inv255f;
-        const GLfloat fa = ((GLfloat)a) * inv255f;
-        data->glColor4f(fr, fg, fb, fa);
-        data->drawstate.color = color;
-    }
-
-    if (data->drawstate.viewport_dirty) {
-        const SDL_Rect *viewport = &data->drawstate.viewport;
-        const SDL_bool istarget = (data->drawstate.target != NULL);
-        data->glMatrixMode(GL_PROJECTION);
-        data->glLoadIdentity();
-        data->glViewport(viewport->x,
-                         istarget ? viewport->y : (data->drawstate.drawableh - viewport->y - viewport->h),
-                         viewport->w, viewport->h);
-        if (viewport->w && viewport->h) {
-            data->glOrthof((GLfloat)0, (GLfloat)viewport->w,
-                           (GLfloat)(istarget ? 0 : viewport->h),
-                           (GLfloat)(istarget ? viewport->h : 0),
-                           0.0, 1.0);
-        }
-        data->glMatrixMode(GL_MODELVIEW);
-        data->drawstate.viewport_dirty = SDL_FALSE;
-    }
-
-    if (data->drawstate.cliprect_enabled_dirty) {
-        if (data->drawstate.cliprect_enabled) {
-            data->glEnable(GL_SCISSOR_TEST);
-        } else {
-            data->glDisable(GL_SCISSOR_TEST);
-        }
-        data->drawstate.cliprect_enabled_dirty = SDL_FALSE;
-    }
-
-    if (data->drawstate.cliprect_enabled && data->drawstate.cliprect_dirty) {
-        const SDL_Rect *viewport = &data->drawstate.viewport;
-        const SDL_Rect *rect = &data->drawstate.cliprect;
-        const SDL_bool istarget = (data->drawstate.target != NULL);
-        data->glScissor(viewport->x + rect->x,
-                        istarget ? viewport->y + rect->y : data->drawstate.drawableh - viewport->y - rect->y - rect->h,
-                        rect->w, rect->h);
-        data->drawstate.cliprect_dirty = SDL_FALSE;
-    }
-
-    if (blend != data->drawstate.blend) {
-        if (blend == SDL_BLENDMODE_NONE) {
-            data->glDisable(GL_BLEND);
-        } else {
-            data->glEnable(GL_BLEND);
-            if (data->GL_OES_blend_func_separate_supported) {
-                data->glBlendFuncSeparateOES(GetBlendFunc(SDL_GetBlendModeSrcColorFactor(blend)),
-                                             GetBlendFunc(SDL_GetBlendModeDstColorFactor(blend)),
-                                             GetBlendFunc(SDL_GetBlendModeSrcAlphaFactor(blend)),
-                                             GetBlendFunc(SDL_GetBlendModeDstAlphaFactor(blend)));
-            } else {
-                data->glBlendFunc(GetBlendFunc(SDL_GetBlendModeSrcColorFactor(blend)),
-                                  GetBlendFunc(SDL_GetBlendModeDstColorFactor(blend)));
-            }
-            if (data->GL_OES_blend_equation_separate_supported) {
-                data->glBlendEquationSeparateOES(GetBlendEquation(SDL_GetBlendModeColorOperation(blend)),
-                                                 GetBlendEquation(SDL_GetBlendModeAlphaOperation(blend)));
-            } else if (data->GL_OES_blend_subtract_supported) {
-                data->glBlendEquationOES(GetBlendEquation(SDL_GetBlendModeColorOperation(blend)));
-            }
-        }
-        data->drawstate.blend = blend;
-    }
-
-    if ((cmd->data.draw.texture != NULL) != data->drawstate.texturing) {
-        if (cmd->data.draw.texture == NULL) {
-            data->glDisable(GL_TEXTURE_2D);
-            data->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-            data->drawstate.texturing = SDL_FALSE;
-        } else {
-            data->glEnable(GL_TEXTURE_2D);
-            data->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-            data->drawstate.texturing = SDL_TRUE;
-        }
-    }
-}
-
-static void SetCopyState(GLES_RenderData *data, const SDL_RenderCommand *cmd)
-{
-    SDL_Texture *texture = cmd->data.draw.texture;
-    SetDrawState(data, cmd);
-
-    if (texture != data->drawstate.texture) {
-        GLES_TextureData *texturedata = (GLES_TextureData *)texture->driverdata;
-        data->glBindTexture(GL_TEXTURE_2D, texturedata->texture);
-        data->drawstate.texture = texture;
-    }
-}
-
-static int GLES_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
-{
-    GLES_RenderData *data = (GLES_RenderData *)renderer->driverdata;
-
-    if (GLES_ActivateRenderer(renderer) < 0) {
-        return -1;
-    }
-
-    data->drawstate.target = renderer->target;
-
-    if (!renderer->target) {
-        int w, h;
-        SDL_GL_GetDrawableSize(renderer->window, &w, &h);
-        if ((w != data->drawstate.drawablew) || (h != data->drawstate.drawableh)) {
-            data->drawstate.viewport_dirty = SDL_TRUE; // if the window dimensions changed, invalidate the current viewport, etc.
-            data->drawstate.cliprect_dirty = SDL_TRUE;
-            data->drawstate.drawablew = w;
-            data->drawstate.drawableh = h;
-        }
-    }
-
-    while (cmd) {
-        switch (cmd->command) {
-        case SDL_RENDERCMD_SETDRAWCOLOR:
-        {
-            break; /* not used in this render backend. */
-        }
-
-        case SDL_RENDERCMD_SETVIEWPORT:
-        {
-            SDL_Rect *viewport = &data->drawstate.viewport;
-            if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
-                SDL_copyp(viewport, &cmd->data.viewport.rect);
-                data->drawstate.viewport_dirty = SDL_TRUE;
-            }
-            break;
-        }
-
-        case SDL_RENDERCMD_SETCLIPRECT:
-        {
-            const SDL_Rect *rect = &cmd->data.cliprect.rect;
-            if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) {
-                data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;
-                data->drawstate.cliprect_enabled_dirty = SDL_TRUE;
-            }
-            if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof(*rect)) != 0) {
-                SDL_copyp(&data->drawstate.cliprect, rect);
-                data->drawstate.cliprect_dirty = SDL_TRUE;
-            }
-            break;
-        }
-
-        case SDL_RENDERCMD_CLEAR:
-        {
-            const Uint8 r = cmd->data.color.r;
-            const Uint8 g = cmd->data.color.g;
-            const Uint8 b = cmd->data.color.b;
-            const Uint8 a = cmd->data.color.a;
-            const Uint32 color = (((Uint32)a << 24) | (r << 16) | (g << 8) | b);
-            if (color != data->drawstate.clear_color) {
-                const GLfloat fr = ((GLfloat)r) * inv255f;
-                const GLfloat fg = ((GLfloat)g) * inv255f;
-                const GLfloat fb = ((GLfloat)b) * inv255f;
-                const GLfloat fa = ((GLfloat)a) * inv255f;
-                data->glClearColor(fr, fg, fb, fa);
-                data->drawstate.clear_color = color;
-            }
-
-            if (data->drawstate.cliprect_enabled || data->drawstate.cliprect_enabled_dirty) {
-                data->glDisable(GL_SCISSOR_TEST);
-                data->drawstate.cliprect_enabled_dirty = data->drawstate.cliprect_enabled;
-            }
-
-            data->glClear(GL_COLOR_BUFFER_BIT);
-
-            break;
-        }
-
-        case SDL_RENDERCMD_DRAW_POINTS:
-        {
-            const size_t count = cmd->data.draw.count;
-            const GLfloat *verts = (GLfloat *)(((Uint8 *)vertices) + cmd->data.draw.first);
-            SetDrawState(data, cmd);
-            data->glVertexPointer(2, GL_FLOAT, 0, verts);
-            data->glDrawArrays(GL_POINTS, 0, (GLsizei)count);
-            break;
-        }
-
-        case SDL_RENDERCMD_DRAW_LINES:
-        {
-            const GLfloat *verts = (GLfloat *)(((Uint8 *)vertices) + cmd->data.draw.first);
-            const size_t count = cmd->data.draw.count;
-            SDL_assert(count >= 2);
-            SetDrawState(data, cmd);
-            data->glVertexPointer(2, GL_FLOAT, 0, verts);
-            data->glDrawArrays(GL_LINE_STRIP, 0, (GLsizei)count);
-            break;
-        }
-
-        case SDL_RENDERCMD_FILL_RECTS: /* unused */
-            break;
-
-        case SDL_RENDERCMD_COPY: /* unused */
-            break;
-
-        case SDL_RENDERCMD_COPY_EX: /* unused */
-            break;
-
-        case SDL_RENDERCMD_GEOMETRY:
-        {
-            const GLfloat *verts = (GLfloat *)(((Uint8 *)vertices) + cmd->data.draw.first);
-            SDL_Texture *texture = cmd->data.draw.texture;
-            const size_t count = cmd->data.draw.count;
-            int stride = (2 + 4 + (texture ? 2 : 0)) * sizeof(float);
-
-            if (texture) {
-                SetCopyState(data, cmd);
-            } else {
-                SetDrawState(data, cmd);
-            }
-
-            data->glEnableClientState(GL_COLOR_ARRAY);
-
-            data->glVertexPointer(2, GL_FLOAT, stride, verts);
-            data->glColorPointer(4, GL_FLOAT, stride, verts + 2);
-            if (texture) {
-                data->glTexCoordPointer(2, GL_FLOAT, stride, verts + 2 + 4);
-            }
-
-            data->glDrawArrays(GL_TRIANGLES, 0, (GLsizei)count);
-
-            data->glDisableClientState(GL_COLOR_ARRAY);
-            break;
-        }
-
-        case SDL_RENDERCMD_NO_OP:
-            break;
-        }
-
-        cmd = cmd->next;
-    }
-
-    return 0;
-}
-
-static int GLES_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect,
-                                 Uint32 pixel_format, void *pixels, int pitch)
-{
-    GLES_RenderData *data = (GLES_RenderData *)renderer->driverdata;
-    Uint32 temp_format = renderer->target ? renderer->target->format : SDL_PIXELFORMAT_ABGR8888;
-    void *temp_pixels;
-    int temp_pitch;
-    Uint8 *src, *dst, *tmp;
-    int w, h, length, rows;
-    int status;
-
-    GLES_ActivateRenderer(renderer);
-
-    temp_pitch = rect->w * SDL_BYTESPERPIXEL(temp_format);
-    temp_pixels = SDL_malloc(rect->h * temp_pitch);
-    if (temp_pixels == NULL) {
-        return SDL_OutOfMemory();
-    }
-
-    SDL_GetRendererOutputSize(renderer, &w, &h);
-
-    data->glPixelStorei(GL_PACK_ALIGNMENT, 1);
-
-    data->glReadPixels(rect->x, renderer->target ? rect->y : (h - rect->y) - rect->h,
-                       rect->w, rect->h, GL_RGBA, GL_UNSIGNED_BYTE, temp_pixels);
-
-    /* Flip the rows to be top-down if necessary */
-    if (!renderer->target) {
-        SDL_bool isstack;
-        length = rect->w * SDL_BYTESPERPIXEL(temp_format);
-        src = (Uint8 *)temp_pixels + (rect->h - 1) * temp_pitch;
-        dst = (Uint8 *)temp_pixels;
-        tmp = SDL_small_alloc(Uint8, length, &isstack);
-        rows = rect->h / 2;
-        while (rows--) {
-            SDL_memcpy(tmp, dst, length);
-            SDL_memcpy(dst, src, length);
-            SDL_memcpy(src, tmp, length);
-            dst += temp_pitch;
-            src -= temp_pitch;
-        }
-        SDL_small_free(tmp, isstack);
-    }
-
-    status = SDL_ConvertPixels(rect->w, rect->h,
-                               temp_format, temp_pixels, temp_pitch,
-                               pixel_format, pixels, pitch);
-    SDL_free(temp_pixels);
-
-    return status;
-}
-
-static int GLES_RenderPresent(SDL_Renderer *renderer)
-{
-    GLES_ActivateRenderer(renderer);
-
-    return SDL_GL_SwapWindowWithResult(renderer->window);
-}
-
-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);
-
-    if (renderdata->drawstate.texture == texture) {
-        renderdata->drawstate.texture = NULL;
-    }
-    if (renderdata->drawstate.target == texture) {
-        renderdata->drawstate.target = NULL;
-    }
-
-    if (data == NULL) {
-        return;
-    }
-    if (data->texture) {
-        renderdata->glDeleteTextures(1, &data->texture);
-    }
-    SDL_free(data->pixels);
-    SDL_free(data);
-    texture->driverdata = NULL;
-}
-
-static void GLES_DestroyRenderer(SDL_Renderer *renderer)
-{
-    GLES_RenderData *data = (GLES_RenderData *)renderer->driverdata;
-
-    if (data) {
-        if (data->context) {
-            while (data->framebuffers) {
-                GLES_FBOList *nextnode = data->framebuffers->next;
-                data->glDeleteFramebuffersOES(1, &data->framebuffers->FBO);
-                SDL_free(data->framebuffers);
-                data->framebuffers = nextnode;
-            }
-            SDL_GL_DeleteContext(data->context);
-        }
-        SDL_free(data);
-    }
-    SDL_free(renderer);
-}
-
-static int GLES_BindTexture(SDL_Renderer *renderer, SDL_Texture *texture, float *texw, float *texh)
-{
-    GLES_RenderData *data = (GLES_RenderData *)renderer->driverdata;
-    GLES_TextureData *texturedata = (GLES_TextureData *)texture->driverdata;
-    GLES_ActivateRenderer(renderer);
-
-    data->glEnable(GL_TEXTURE_2D);
-    data->glBindTexture(texturedata->type, texturedata->texture);
-
-    data->drawstate.texture = texture;
-    data->drawstate.texturing = SDL_TRUE;
-
-    if (texw) {
-        *texw = (float)texturedata->texw;
-    }
-    if (texh) {
-        *texh = (float)texturedata->texh;
-    }
-
-    return 0;
-}
-
-static int GLES_UnbindTexture(SDL_Renderer *renderer, SDL_Texture *texture)
-{
-    GLES_RenderData *data = (GLES_RenderData *)renderer->driverdata;
-    GLES_TextureData *texturedata = (GLES_TextureData *)texture->driverdata;
-    GLES_ActivateRenderer(renderer);
-    data->glDisable(texturedata->type);
-
-    data->drawstate.texture = NULL;
-    data->drawstate.texturing = SDL_FALSE;
-
-    return 0;
-}
-
-static int GLES_SetVSync(SDL_Renderer *renderer, const int vsync)
-{
-    int retval;
-    if (vsync) {
-        retval = SDL_GL_SetSwapInterval(1);
-    } else {
-        retval = SDL_GL_SetSwapInterval(0);
-    }
-    if (retval != 0) {
-        return retval;
-    }
-    if (SDL_GL_GetSwapInterval() > 0) {
-        renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
-    } else {
-        renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
-    }
-    return retval;
-}
-
-static SDL_Renderer *GLES_CreateRenderer(SDL_Window *window, Uint32 flags)
-{
-    SDL_Renderer *renderer;
-    GLES_RenderData *data;
-    GLint value;
-    Uint32 window_flags;
-    int profile_mask = 0, major = 0, minor = 0;
-    SDL_bool changed_window = SDL_FALSE;
-
-    SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile_mask);
-    SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &major);
-    SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &minor);
-
-    window_flags = SDL_GetWindowFlags(window);
-    if (!(window_flags & SDL_WINDOW_OPENGL) ||
-        profile_mask != SDL_GL_CONTEXT_PROFILE_ES || major != RENDERER_CONTEXT_MAJOR || minor != RENDERER_CONTEXT_MINOR) {
-
-        changed_window = SDL_TRUE;
-        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
-        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RENDERER_CONTEXT_MAJOR);
-        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RENDERER_CONTEXT_MINOR);
-
-        if (SDL_RecreateWindow(window, (window_flags & ~(SDL_WINDOW_VULKAN | SDL_WINDOW_METAL)) | SDL_WINDOW_OPENGL) < 0) {
-            goto error;
-        }
-    }
-
-    renderer = (SDL_Renderer *)SDL_calloc(1, sizeof(*renderer));
-    if (renderer == NULL) {
-        SDL_OutOfMemory();
-        goto error;
-    }
-
-    data = (GLES_RenderData *)SDL_calloc(1, sizeof(*data));
-    if (data == NULL) {
-        GLES_DestroyRenderer(renderer);
-        SDL_OutOfMemory();
-        goto error;
-    }
-
-    renderer->WindowEvent = GLES_WindowEvent;
-    renderer->GetOutputSize = GLES_GetOutputSize;
-    renderer->SupportsBlendMode = GLES_SupportsBlendMode;
-    renderer->CreateTexture = GLES_CreateTexture;
-    renderer->UpdateTexture = GLES_UpdateTexture;
-    renderer->LockTexture = GLES_LockTexture;
-    renderer->UnlockTexture = GLES_UnlockTexture;
-    renderer->SetTextureScaleMode = GLES_SetTextureScaleMode;
-    renderer->SetRenderTarget = GLES_SetRenderTarget;
-    renderer->QueueSetViewport = GLES_QueueSetViewport;
-    renderer->QueueSetDrawColor = GLES_QueueSetViewport; /* SetViewport and SetDrawColor are (currently) no-ops. */
-    renderer->QueueDrawPoints = GLES_QueueDrawPoints;
-    renderer->QueueDrawLines = GLES_QueueDrawLines;
-    renderer->QueueGeometry = GLES_QueueGeometry;
-    renderer->RunCommandQueue = GLES_RunCommandQueue;
-    renderer->RenderReadPixels = GLES_RenderReadPixels;
-    renderer->RenderPresent = GLES_RenderPresent;
-    renderer->DestroyTexture = GLES_DestroyTexture;
-    renderer->DestroyRenderer = GLES_DestroyRenderer;
-    renderer->SetVSync = GLES_SetVSync;
-    renderer->GL_BindTexture = GLES_BindTexture;
-    renderer->GL_UnbindTexture = GLES_UnbindTexture;
-    renderer->info = GLES_RenderDriver.info;
-    renderer->info.flags = SDL_RENDERER_ACCELERATED;
-    renderer->driverdata = data;
-    renderer->window = window;
-
-    data->context = SDL_GL_CreateContext(window);
-    if (!data->context) {
-        GLES_DestroyRenderer(renderer);
-        goto error;
-    }
-    if (SDL_GL_MakeCurrent(window, data->context) < 0) {
-        GLES_DestroyRenderer(renderer);
-        goto error;
-    }
-
-    if (GLES_LoadFunctions(data) < 0) {
-        GLES_DestroyRenderer(renderer);
-        goto error;
-    }
-
-    if (flags & SDL_RENDERER_PRESENTVSYNC) {
-        SDL_GL_SetSwapInterval(1);
-    } else {
-        SDL_GL_SetSwapInterval(0);
-    }
-    if (SDL_GL_GetSwapInterval() > 0) {
-        renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
-    }
-
-    value = 0;
-    data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
-    renderer->info.max_texture_width = value;
-    value = 0;
-    data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
-    renderer->info.max_texture_height = value;
-
-    /* Android does not report GL_OES_framebuffer_object but the functionality seems to be there anyway */
-    if (SDL_GL_ExtensionSupported("GL_OES_framebuffer_object") || data->glGenFramebuffersOES) {
-        data->GL_OES_framebuffer_object_supported = SDL_TRUE;
-        renderer->info.flags |= SDL_RENDERER_TARGETTEXTURE;
-
-        value = 0;
-        data->glGetIntegerv(GL_FRAMEBUFFER_BINDING_OES, &value);
-        data->window_framebuffer = (GLuint)value;
-    }
-    data->framebuffers = NULL;
-
-    if (SDL_GL_ExtensionSupported("GL_OES_blend_func_separate")) {
-        data->GL_OES_blend_func_separate_supported = SDL_TRUE;
-    }
-    if (SDL_GL_ExtensionSupported("GL_OES_blend_equation_separate")) {
-        data->GL_OES_blend_equation_separate_supported = SDL_TRUE;
-    }
-    if (SDL_GL_ExtensionSupported("GL_OES_blend_subtract")) {
-        data->GL_OES_blend_subtract_supported = SDL_TRUE;
-    }
-
-    /* Set up parameters for rendering */
-    data->glDisable(GL_DEPTH_TEST);
-    data->glDisable(GL_CULL_FACE);
-
-    data->glMatrixMode(GL_MODELVIEW);
-    data->glLoadIdentity();
-
-    data->glEnableClientState(GL_VERTEX_ARRAY);
-    data->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-
-    data->glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
-
-    data->drawstate.blend = SDL_BLENDMODE_INVALID;
-    data->drawstate.color = 0xFFFFFFFF;
-    data->drawstate.clear_color = 0xFFFFFFFF;
-
-    return renderer;
-
-error:
-    if (changed_window) {
-        /* Uh oh, better try to put it back... */
-        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profile_mask);
-        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, major);
-        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minor);
-        SDL_RecreateWindow(window, window_flags);
-    }
-    return NULL;
-}
-
-SDL_RenderDriver GLES_RenderDriver = {
-    GLES_CreateRenderer,
-    { "opengles",
-      (SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC),
-      1,
-      { SDL_PIXELFORMAT_ABGR8888 },
-      0,
-      0 }
-};
-
-#endif /* SDL_VIDEO_RENDER_OGL_ES && !SDL_RENDER_DISABLED */
-
-/* vi: set ts=4 sw=4 expandtab: */