src/render/opengles2/SDL_render_gles2.c
author Gabriel Jacobo <gabomdq@gmail.com>
Thu, 22 Aug 2013 17:26:22 -0300
changeset 7691 cf99258f905c
parent 7624 ac9f3b12c42a
child 7719 31b5f9ff36ca
permissions -rw-r--r--
Fix warning in GL ES2 renderer
slouken@5201
     1
/*
slouken@5535
     2
  Simple DirectMedia Layer
slouken@6885
     3
  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
slouken@5201
     4
slouken@5535
     5
  This software is provided 'as-is', without any express or implied
slouken@5535
     6
  warranty.  In no event will the authors be held liable for any damages
slouken@5535
     7
  arising from the use of this software.
slouken@5201
     8
slouken@5535
     9
  Permission is granted to anyone to use this software for any purpose,
slouken@5535
    10
  including commercial applications, and to alter it and redistribute it
slouken@5535
    11
  freely, subject to the following restrictions:
slouken@5201
    12
slouken@5535
    13
  1. The origin of this software must not be misrepresented; you must not
slouken@5535
    14
     claim that you wrote the original software. If you use this software
slouken@5535
    15
     in a product, an acknowledgment in the product documentation would be
slouken@5535
    16
     appreciated but is not required.
slouken@5535
    17
  2. Altered source versions must be plainly marked as such, and must not be
slouken@5535
    18
     misrepresented as being the original software.
slouken@5535
    19
  3. This notice may not be removed or altered from any source distribution.
slouken@5201
    20
*/
slouken@5201
    21
#include "SDL_config.h"
slouken@5201
    22
slouken@5226
    23
#if SDL_VIDEO_RENDER_OGL_ES2 && !SDL_RENDER_DISABLED
slouken@5201
    24
slouken@5484
    25
#include "SDL_hints.h"
slouken@5204
    26
#include "SDL_opengles2.h"
slouken@5201
    27
#include "../SDL_sysrender.h"
slouken@5201
    28
#include "SDL_shaders_gles2.h"
slouken@5201
    29
slouken@6190
    30
/* Used to re-create the window with OpenGL ES capability */
slouken@6188
    31
extern int SDL_RecreateWindow(SDL_Window * window, Uint32 flags);
slouken@6188
    32
slouken@5201
    33
/*************************************************************************************************
slouken@5201
    34
 * Bootstrap data                                                                                *
slouken@5201
    35
 *************************************************************************************************/
slouken@5201
    36
slouken@5201
    37
static SDL_Renderer *GLES2_CreateRenderer(SDL_Window *window, Uint32 flags);
slouken@5201
    38
slouken@5201
    39
SDL_RenderDriver GLES2_RenderDriver = {
slouken@5201
    40
    GLES2_CreateRenderer,
slouken@5201
    41
    {
slouken@5201
    42
        "opengles2",
slouken@6237
    43
        (SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE),
slouken@6113
    44
        4,
slouken@6113
    45
        {SDL_PIXELFORMAT_ABGR8888,
slouken@6113
    46
        SDL_PIXELFORMAT_ARGB8888,
slouken@6113
    47
        SDL_PIXELFORMAT_RGB888,
slouken@6113
    48
        SDL_PIXELFORMAT_BGR888},
slouken@5201
    49
        0,
slouken@5201
    50
        0
slouken@5201
    51
    }
slouken@5201
    52
};
slouken@5201
    53
slouken@5201
    54
/*************************************************************************************************
slouken@5201
    55
 * Context structures                                                                            *
slouken@5201
    56
 *************************************************************************************************/
slouken@5201
    57
slouken@6232
    58
typedef struct GLES2_FBOList GLES2_FBOList;
slouken@6232
    59
slouken@6232
    60
struct GLES2_FBOList
slouken@6232
    61
{
slouken@6232
    62
   Uint32 w, h;
slouken@6232
    63
   GLuint FBO;
slouken@6232
    64
   GLES2_FBOList *next;
slouken@6232
    65
};
slouken@6232
    66
slouken@5201
    67
typedef struct GLES2_TextureData
slouken@5201
    68
{
slouken@5201
    69
    GLenum texture;
slouken@5201
    70
    GLenum texture_type;
slouken@5201
    71
    GLenum pixel_format;
slouken@5201
    72
    GLenum pixel_type;
slouken@5201
    73
    void *pixel_data;
slouken@5201
    74
    size_t pitch;
slouken@6232
    75
    GLES2_FBOList *fbo;
slouken@5201
    76
} GLES2_TextureData;
slouken@5201
    77
slouken@5201
    78
typedef struct GLES2_ShaderCacheEntry
slouken@5201
    79
{
slouken@5201
    80
    GLuint id;
slouken@5201
    81
    GLES2_ShaderType type;
slouken@5201
    82
    const GLES2_ShaderInstance *instance;
slouken@5201
    83
    int references;
slouken@5201
    84
    struct GLES2_ShaderCacheEntry *prev;
slouken@5201
    85
    struct GLES2_ShaderCacheEntry *next;
slouken@5201
    86
} GLES2_ShaderCacheEntry;
slouken@5201
    87
slouken@5201
    88
typedef struct GLES2_ShaderCache
slouken@5201
    89
{
slouken@5201
    90
    int count;
slouken@5201
    91
    GLES2_ShaderCacheEntry *head;
slouken@5201
    92
} GLES2_ShaderCache;
slouken@5201
    93
slouken@5201
    94
typedef struct GLES2_ProgramCacheEntry
slouken@5201
    95
{
slouken@5201
    96
    GLuint id;
slouken@5201
    97
    SDL_BlendMode blend_mode;
slouken@5201
    98
    GLES2_ShaderCacheEntry *vertex_shader;
slouken@5201
    99
    GLES2_ShaderCacheEntry *fragment_shader;
slouken@5201
   100
    GLuint uniform_locations[16];
slouken@5201
   101
    struct GLES2_ProgramCacheEntry *prev;
slouken@5201
   102
    struct GLES2_ProgramCacheEntry *next;
slouken@5201
   103
} GLES2_ProgramCacheEntry;
slouken@5201
   104
slouken@5201
   105
typedef struct GLES2_ProgramCache
slouken@5201
   106
{
slouken@5201
   107
    int count;
slouken@5201
   108
    GLES2_ProgramCacheEntry *head;
slouken@5201
   109
    GLES2_ProgramCacheEntry *tail;
slouken@5201
   110
} GLES2_ProgramCache;
slouken@5201
   111
slouken@5201
   112
typedef enum
slouken@5201
   113
{
slouken@5201
   114
    GLES2_ATTRIBUTE_POSITION = 0,
gabomdq@6320
   115
    GLES2_ATTRIBUTE_TEXCOORD = 1,
gabomdq@6320
   116
    GLES2_ATTRIBUTE_ANGLE = 2,
gabomdq@6320
   117
    GLES2_ATTRIBUTE_CENTER = 3,
slouken@5201
   118
} GLES2_Attribute;
slouken@5201
   119
slouken@5201
   120
typedef enum
slouken@5201
   121
{
slouken@5201
   122
    GLES2_UNIFORM_PROJECTION,
slouken@5201
   123
    GLES2_UNIFORM_TEXTURE,
slouken@5201
   124
    GLES2_UNIFORM_MODULATION,
slouken@5201
   125
    GLES2_UNIFORM_COLOR,
slouken@5201
   126
    GLES2_UNIFORM_COLORTABLE
slouken@5201
   127
} GLES2_Uniform;
slouken@5201
   128
slouken@5201
   129
typedef enum
slouken@5201
   130
{
slouken@5201
   131
    GLES2_IMAGESOURCE_SOLID,
slouken@6113
   132
    GLES2_IMAGESOURCE_TEXTURE_ABGR,
slouken@6113
   133
    GLES2_IMAGESOURCE_TEXTURE_ARGB,
slouken@6113
   134
    GLES2_IMAGESOURCE_TEXTURE_RGB,
slouken@6113
   135
    GLES2_IMAGESOURCE_TEXTURE_BGR
slouken@5201
   136
} GLES2_ImageSource;
slouken@5201
   137
slouken@5201
   138
typedef struct GLES2_DriverContext
slouken@5201
   139
{
slouken@5201
   140
    SDL_GLContext *context;
slouken@5355
   141
    struct {
slouken@5355
   142
        int blendMode;
slouken@5355
   143
        SDL_bool tex_coords;
slouken@5355
   144
    } current;
slouken@5355
   145
slouken@6188
   146
#define SDL_PROC(ret,func,params) ret (APIENTRY *func) params;
slouken@6188
   147
#include "SDL_gles2funcs.h"
slouken@6188
   148
#undef SDL_PROC
slouken@6232
   149
    GLES2_FBOList *framebuffers;
slouken@6271
   150
    GLuint window_framebuffer;
slouken@6188
   151
slouken@5201
   152
    int shader_format_count;
slouken@5201
   153
    GLenum *shader_formats;
slouken@5201
   154
    GLES2_ShaderCache shader_cache;
slouken@5201
   155
    GLES2_ProgramCache program_cache;
slouken@5201
   156
    GLES2_ProgramCacheEntry *current_program;
slouken@5201
   157
} GLES2_DriverContext;
slouken@5201
   158
slouken@5201
   159
#define GLES2_MAX_CACHED_PROGRAMS 8
slouken@5201
   160
slouken@5201
   161
/*************************************************************************************************
slouken@5201
   162
 * Renderer state APIs                                                                           *
slouken@5201
   163
 *************************************************************************************************/
slouken@5201
   164
slouken@5224
   165
static int GLES2_ActivateRenderer(SDL_Renderer *renderer);
slouken@5201
   166
static void GLES2_WindowEvent(SDL_Renderer * renderer,
slouken@5201
   167
                              const SDL_WindowEvent *event);
slouken@5297
   168
static int GLES2_UpdateViewport(SDL_Renderer * renderer);
slouken@5201
   169
static void GLES2_DestroyRenderer(SDL_Renderer *renderer);
slouken@6246
   170
static int GLES2_SetOrthographicProjection(SDL_Renderer *renderer);
slouken@5201
   171
slouken@6232
   172
slouken@5201
   173
static SDL_GLContext SDL_CurrentContext = NULL;
slouken@5201
   174
slouken@6188
   175
static int GLES2_LoadFunctions(GLES2_DriverContext * data)
slouken@6188
   176
{
slouken@6190
   177
#if SDL_VIDEO_DRIVER_UIKIT
slouken@6190
   178
#define __SDL_NOGETPROCADDR__
slouken@6190
   179
#elif SDL_VIDEO_DRIVER_ANDROID
slouken@6190
   180
#define __SDL_NOGETPROCADDR__
slouken@6190
   181
#elif SDL_VIDEO_DRIVER_PANDORA
slouken@6190
   182
#define __SDL_NOGETPROCADDR__
slouken@6190
   183
#endif
slouken@6190
   184
slouken@6190
   185
#if defined __SDL_NOGETPROCADDR__
slouken@6188
   186
#define SDL_PROC(ret,func,params) data->func=func;
slouken@6188
   187
#else
slouken@6188
   188
#define SDL_PROC(ret,func,params) \
slouken@6188
   189
    do { \
slouken@6188
   190
        data->func = SDL_GL_GetProcAddress(#func); \
slouken@6188
   191
        if ( ! data->func ) { \
icculus@7037
   192
            return SDL_SetError("Couldn't load GLES2 function %s: %s\n", #func, SDL_GetError()); \
slouken@6188
   193
        } \
slouken@6232
   194
    } while ( 0 );
slouken@6188
   195
#endif /* _SDL_NOGETPROCADDR_ */
slouken@6188
   196
slouken@6188
   197
#include "SDL_gles2funcs.h"
slouken@6188
   198
#undef SDL_PROC
slouken@6188
   199
    return 0;
slouken@6188
   200
}
slouken@6188
   201
slouken@6232
   202
GLES2_FBOList *
slouken@6232
   203
GLES2_GetFBO(GLES2_DriverContext *data, Uint32 w, Uint32 h)
slouken@6232
   204
{
slouken@6232
   205
   GLES2_FBOList *result = data->framebuffers;
slouken@6232
   206
   while ((result) && ((result->w != w) || (result->h != h)) )
slouken@6232
   207
   {
slouken@6232
   208
       result = result->next;
slouken@6232
   209
   }
slouken@6232
   210
   if (result == NULL)
slouken@6232
   211
   {
slouken@6232
   212
       result = SDL_malloc(sizeof(GLES2_FBOList));
slouken@6232
   213
       result->w = w;
slouken@6232
   214
       result->h = h;
slouken@6269
   215
       data->glGenFramebuffers(1, &result->FBO);
slouken@6232
   216
       result->next = data->framebuffers;
slouken@6232
   217
       data->framebuffers = result;
slouken@6232
   218
   }
slouken@6232
   219
   return result;
slouken@6232
   220
}
slouken@6232
   221
slouken@5201
   222
static int
slouken@5201
   223
GLES2_ActivateRenderer(SDL_Renderer * renderer)
slouken@5201
   224
{
slouken@5201
   225
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   226
slouken@5201
   227
    if (SDL_CurrentContext != rdata->context) {
slouken@5201
   228
        /* Null out the current program to ensure we set it again */
slouken@5201
   229
        rdata->current_program = NULL;
slouken@5201
   230
slouken@5297
   231
        if (SDL_GL_MakeCurrent(renderer->window, rdata->context) < 0) {
slouken@5201
   232
            return -1;
slouken@5201
   233
        }
slouken@5201
   234
        SDL_CurrentContext = rdata->context;
slouken@5201
   235
slouken@5297
   236
        GLES2_UpdateViewport(renderer);
slouken@5201
   237
    }
slouken@5201
   238
    return 0;
slouken@5201
   239
}
slouken@5201
   240
slouken@5201
   241
static void
slouken@5201
   242
GLES2_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
slouken@5201
   243
{
slouken@6188
   244
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@6232
   245
slouken@6260
   246
    if (event->event == SDL_WINDOWEVENT_SIZE_CHANGED ||
slouken@6260
   247
        event->event == SDL_WINDOWEVENT_SHOWN ||
slouken@6260
   248
        event->event == SDL_WINDOWEVENT_HIDDEN) {
slouken@5201
   249
        /* Rebind the context to the window area */
slouken@5201
   250
        SDL_CurrentContext = NULL;
slouken@5201
   251
    }
slouken@6060
   252
slouken@6060
   253
    if (event->event == SDL_WINDOWEVENT_MINIMIZED) {
slouken@6060
   254
        /* According to Apple documentation, we need to finish drawing NOW! */
slouken@6188
   255
        rdata->glFinish();
slouken@6060
   256
    }
slouken@5201
   257
}
slouken@5201
   258
slouken@5297
   259
static int
slouken@5297
   260
GLES2_UpdateViewport(SDL_Renderer * renderer)
slouken@5224
   261
{
slouken@5297
   262
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5224
   263
slouken@5297
   264
    if (SDL_CurrentContext != rdata->context) {
slouken@5297
   265
        /* We'll update the viewport after we rebind the context */
slouken@5297
   266
        return 0;
slouken@5297
   267
    }
slouken@5224
   268
slouken@6188
   269
    rdata->glViewport(renderer->viewport.x, renderer->viewport.y,
slouken@5297
   270
               renderer->viewport.w, renderer->viewport.h);
slouken@6268
   271
slouken@6268
   272
    if (rdata->current_program) {
slouken@6268
   273
        GLES2_SetOrthographicProjection(renderer);
slouken@6268
   274
    }
slouken@5297
   275
    return 0;
slouken@5224
   276
}
slouken@5224
   277
slouken@7141
   278
static int
slouken@7141
   279
GLES2_UpdateClipRect(SDL_Renderer * renderer)
slouken@7141
   280
{
gabomdq@7160
   281
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@7141
   282
    const SDL_Rect *rect = &renderer->clip_rect;
slouken@7141
   283
gabomdq@7160
   284
    if (SDL_CurrentContext != rdata->context) {
gabomdq@7160
   285
        /* We'll update the clip rect after we rebind the context */
gabomdq@7160
   286
        return 0;
gabomdq@7160
   287
    }
gabomdq@7160
   288
slouken@7141
   289
    if (!SDL_RectEmpty(rect)) {
gabomdq@7160
   290
        rdata->glEnable(GL_SCISSOR_TEST);
philipp@7173
   291
        rdata->glScissor(rect->x, renderer->viewport.h - rect->y - rect->h, rect->w, rect->h);
slouken@7141
   292
    } else {
gabomdq@7160
   293
        rdata->glDisable(GL_SCISSOR_TEST);
slouken@7141
   294
    }
slouken@7141
   295
    return 0;
slouken@7141
   296
}
slouken@7141
   297
slouken@5224
   298
static void
slouken@5201
   299
GLES2_DestroyRenderer(SDL_Renderer *renderer)
slouken@5201
   300
{
slouken@5201
   301
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   302
slouken@5209
   303
    /* Deallocate everything */
slouken@5209
   304
    if (rdata) {
slouken@5209
   305
        GLES2_ActivateRenderer(renderer);
slouken@5201
   306
slouken@6178
   307
        {
slouken@6178
   308
            GLES2_ShaderCacheEntry *entry;
slouken@6178
   309
            GLES2_ShaderCacheEntry *next;
slouken@6178
   310
            entry = rdata->shader_cache.head;
slouken@6178
   311
            while (entry)
slouken@6178
   312
            {
slouken@6188
   313
                rdata->glDeleteShader(entry->id);
slouken@6052
   314
                next = entry->next;
slouken@6052
   315
                SDL_free(entry);
slouken@6052
   316
                entry = next;
slouken@6178
   317
            }
slouken@6178
   318
        }
slouken@6178
   319
        {
slouken@6178
   320
            GLES2_ProgramCacheEntry *entry;
slouken@6178
   321
            GLES2_ProgramCacheEntry *next;
slouken@6052
   322
            entry = rdata->program_cache.head;
slouken@6052
   323
            while (entry) {
slouken@6188
   324
                rdata->glDeleteProgram(entry->id);
slouken@6052
   325
                next = entry->next;
slouken@6052
   326
                SDL_free(entry);
slouken@6052
   327
                entry = next;
slouken@6052
   328
            }
slouken@6178
   329
        }
slouken@5209
   330
        if (rdata->context) {
slouken@6232
   331
            while (rdata->framebuffers) {
slouken@6232
   332
                GLES2_FBOList *nextnode = rdata->framebuffers->next;
slouken@6232
   333
                rdata->glDeleteFramebuffers(1, &rdata->framebuffers->FBO);
slouken@6232
   334
                SDL_free(rdata->framebuffers);
slouken@6232
   335
                rdata->framebuffers = nextnode;
slouken@6232
   336
            }
slouken@5209
   337
            SDL_GL_DeleteContext(rdata->context);
slouken@5209
   338
        }
slouken@5209
   339
        if (rdata->shader_formats) {
slouken@5209
   340
            SDL_free(rdata->shader_formats);
slouken@5209
   341
        }
slouken@5209
   342
        SDL_free(rdata);
slouken@5201
   343
    }
slouken@5201
   344
    SDL_free(renderer);
slouken@5201
   345
}
slouken@5201
   346
slouken@5201
   347
/*************************************************************************************************
slouken@5201
   348
 * Texture APIs                                                                                  *
slouken@5201
   349
 *************************************************************************************************/
slouken@5201
   350
slouken@5201
   351
static int GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture);
slouken@5201
   352
static void GLES2_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture);
slouken@5201
   353
static int GLES2_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,
slouken@5201
   354
                             void **pixels, int *pitch);
slouken@5201
   355
static void GLES2_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture);
slouken@5201
   356
static int GLES2_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,
slouken@5201
   357
                               const void *pixels, int pitch);
slouken@6247
   358
static int GLES2_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture);
slouken@5201
   359
slouken@5484
   360
static GLenum
slouken@5484
   361
GetScaleQuality(void)
slouken@5484
   362
{
slouken@5484
   363
    const char *hint = SDL_GetHint(SDL_HINT_RENDER_SCALE_QUALITY);
slouken@5484
   364
slouken@5484
   365
    if (!hint || *hint == '0' || SDL_strcasecmp(hint, "nearest") == 0) {
slouken@5484
   366
        return GL_NEAREST;
slouken@5484
   367
    } else {
slouken@5484
   368
        return GL_LINEAR;
slouken@5484
   369
    }
slouken@5484
   370
}
slouken@5484
   371
slouken@5201
   372
static int
slouken@5201
   373
GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
slouken@5201
   374
{
slouken@6188
   375
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   376
    GLES2_TextureData *tdata;
slouken@5201
   377
    GLenum format;
slouken@5201
   378
    GLenum type;
slouken@5503
   379
    GLenum scaleMode;
slouken@5201
   380
slouken@5201
   381
    GLES2_ActivateRenderer(renderer);
slouken@5201
   382
slouken@5201
   383
    /* Determine the corresponding GLES texture format params */
slouken@5201
   384
    switch (texture->format)
slouken@5201
   385
    {
slouken@5201
   386
    case SDL_PIXELFORMAT_ABGR8888:
slouken@6113
   387
    case SDL_PIXELFORMAT_ARGB8888:
slouken@6113
   388
    case SDL_PIXELFORMAT_BGR888:
slouken@6113
   389
    case SDL_PIXELFORMAT_RGB888:
slouken@5201
   390
        format = GL_RGBA;
slouken@5201
   391
        type = GL_UNSIGNED_BYTE;
slouken@5201
   392
        break;
slouken@5201
   393
    default:
icculus@7037
   394
        return SDL_SetError("Texture format not supported");
slouken@5201
   395
    }
slouken@5201
   396
slouken@5201
   397
    /* Allocate a texture struct */
slouken@5201
   398
    tdata = (GLES2_TextureData *)SDL_calloc(1, sizeof(GLES2_TextureData));
icculus@7037
   399
    if (!tdata) {
icculus@7037
   400
        return SDL_OutOfMemory();
slouken@5201
   401
    }
slouken@5201
   402
    tdata->texture = 0;
slouken@5201
   403
    tdata->texture_type = GL_TEXTURE_2D;
slouken@5201
   404
    tdata->pixel_format = format;
slouken@5201
   405
    tdata->pixel_type = type;
slouken@5503
   406
    scaleMode = GetScaleQuality();
slouken@5201
   407
slouken@5201
   408
    /* Allocate a blob for image data */
icculus@7037
   409
    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
slouken@5201
   410
        tdata->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
slouken@5402
   411
        tdata->pixel_data = SDL_calloc(1, tdata->pitch * texture->h);
icculus@7037
   412
        if (!tdata->pixel_data) {
slouken@5201
   413
            SDL_free(tdata);
icculus@7037
   414
            return SDL_OutOfMemory();
slouken@5201
   415
        }
slouken@5201
   416
    }
slouken@5201
   417
slouken@5201
   418
    /* Allocate the texture */
slouken@6188
   419
    rdata->glGetError();
slouken@6188
   420
    rdata->glGenTextures(1, &tdata->texture);
slouken@7624
   421
    if (rdata->glGetError() != GL_NO_ERROR) {
slouken@7624
   422
        SDL_free(tdata);
slouken@7624
   423
        return SDL_SetError("Texture creation failed in glGenTextures()");
slouken@7624
   424
    }
slouken@6188
   425
    rdata->glActiveTexture(GL_TEXTURE0);
slouken@6188
   426
    rdata->glBindTexture(tdata->texture_type, tdata->texture);
slouken@6188
   427
    rdata->glTexParameteri(tdata->texture_type, GL_TEXTURE_MIN_FILTER, scaleMode);
slouken@6188
   428
    rdata->glTexParameteri(tdata->texture_type, GL_TEXTURE_MAG_FILTER, scaleMode);
slouken@6188
   429
    rdata->glTexParameteri(tdata->texture_type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
slouken@6188
   430
    rdata->glTexParameteri(tdata->texture_type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
slouken@6188
   431
    rdata->glTexImage2D(tdata->texture_type, 0, format, texture->w, texture->h, 0, format, type, NULL);
slouken@7624
   432
    if (rdata->glGetError() != GL_NO_ERROR) {
slouken@6188
   433
        rdata->glDeleteTextures(1, &tdata->texture);
slouken@5201
   434
        SDL_free(tdata);
icculus@7037
   435
        return SDL_SetError("Texture creation failed");
slouken@5201
   436
    }
slouken@5201
   437
    texture->driverdata = tdata;
slouken@6232
   438
slouken@6232
   439
    if (texture->access == SDL_TEXTUREACCESS_TARGET) {
slouken@6232
   440
       tdata->fbo = GLES2_GetFBO(renderer->driverdata, texture->w, texture->h);
slouken@6232
   441
    } else {
slouken@6232
   442
       tdata->fbo = NULL;
slouken@6232
   443
    }
slouken@6232
   444
slouken@5201
   445
    return 0;
slouken@5201
   446
}
slouken@5201
   447
slouken@5201
   448
static void
slouken@5201
   449
GLES2_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
slouken@5201
   450
{
slouken@6188
   451
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   452
    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
slouken@5201
   453
slouken@5201
   454
    GLES2_ActivateRenderer(renderer);
slouken@5201
   455
slouken@5201
   456
    /* Destroy the texture */
slouken@5201
   457
    if (tdata)
slouken@5201
   458
    {
slouken@6188
   459
        rdata->glDeleteTextures(1, &tdata->texture);
slouken@5201
   460
        SDL_free(tdata->pixel_data);
slouken@5201
   461
        SDL_free(tdata);
slouken@5201
   462
        texture->driverdata = NULL;
slouken@5201
   463
    }
slouken@5201
   464
}
slouken@5201
   465
slouken@5201
   466
static int
slouken@5201
   467
GLES2_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,
slouken@5201
   468
                  void **pixels, int *pitch)
slouken@5201
   469
{
slouken@5201
   470
    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
slouken@5201
   471
slouken@5201
   472
    /* Retrieve the buffer/pitch for the specified region */
slouken@5201
   473
    *pixels = (Uint8 *)tdata->pixel_data +
slouken@5201
   474
              (tdata->pitch * rect->y) +
slouken@5201
   475
              (rect->x * SDL_BYTESPERPIXEL(texture->format));
slouken@5201
   476
    *pitch = tdata->pitch;
slouken@5201
   477
slouken@5201
   478
    return 0;
slouken@5201
   479
}
slouken@5201
   480
slouken@5201
   481
static void
slouken@5201
   482
GLES2_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
slouken@5201
   483
{
slouken@5201
   484
    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
slouken@5227
   485
    SDL_Rect rect;
slouken@5201
   486
slouken@5227
   487
    /* We do whole texture updates, at least for now */
slouken@5227
   488
    rect.x = 0;
slouken@5227
   489
    rect.y = 0;
slouken@5227
   490
    rect.w = texture->w;
slouken@5227
   491
    rect.h = texture->h;
slouken@5227
   492
    GLES2_UpdateTexture(renderer, texture, &rect, tdata->pixel_data, tdata->pitch);
slouken@5201
   493
}
slouken@5201
   494
slouken@5201
   495
static int
slouken@5201
   496
GLES2_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,
slouken@5201
   497
                    const void *pixels, int pitch)
slouken@5201
   498
{
slouken@6188
   499
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   500
    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
slouken@5201
   501
    Uint8 *blob = NULL;
slouken@5201
   502
    Uint8 *src;
slouken@5201
   503
    int srcPitch;
slouken@5201
   504
    int y;
slouken@5201
   505
slouken@5201
   506
    GLES2_ActivateRenderer(renderer);
slouken@6232
   507
slouken@5201
   508
    /* Bail out if we're supposed to update an empty rectangle */
slouken@5201
   509
    if (rect->w <= 0 || rect->h <= 0)
slouken@5201
   510
        return 0;
slouken@5201
   511
slouken@5201
   512
    /* Reformat the texture data into a tightly packed array */
slouken@5201
   513
    srcPitch = rect->w * SDL_BYTESPERPIXEL(texture->format);
slouken@5201
   514
    src = (Uint8 *)pixels;
icculus@7037
   515
    if (pitch != srcPitch) {
slouken@5201
   516
        blob = (Uint8 *)SDL_malloc(srcPitch * rect->h);
icculus@7037
   517
        if (!blob) {
icculus@7037
   518
            return SDL_OutOfMemory();
slouken@5201
   519
        }
slouken@5201
   520
        src = blob;
slouken@5201
   521
        for (y = 0; y < rect->h; ++y)
slouken@5201
   522
        {
slouken@5201
   523
            SDL_memcpy(src, pixels, srcPitch);
slouken@5201
   524
            src += srcPitch;
slouken@5201
   525
            pixels = (Uint8 *)pixels + pitch;
slouken@5201
   526
        }
slouken@5201
   527
        src = blob;
slouken@5201
   528
    }
slouken@5201
   529
slouken@5201
   530
    /* Create a texture subimage with the supplied data */
slouken@6188
   531
    rdata->glGetError();
slouken@6188
   532
    rdata->glActiveTexture(GL_TEXTURE0);
slouken@6188
   533
    rdata->glBindTexture(tdata->texture_type, tdata->texture);
slouken@6188
   534
    rdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
slouken@6188
   535
    rdata->glTexSubImage2D(tdata->texture_type,
slouken@5201
   536
                    0,
slouken@5201
   537
                    rect->x,
slouken@5201
   538
                    rect->y,
slouken@5201
   539
                    rect->w,
slouken@5201
   540
                    rect->h,
slouken@5201
   541
                    tdata->pixel_format,
slouken@5201
   542
                    tdata->pixel_type,
slouken@5201
   543
                    src);
slouken@5227
   544
    if (blob) {
slouken@5227
   545
        SDL_free(blob);
slouken@5227
   546
    }
slouken@5214
   547
icculus@7037
   548
    if (rdata->glGetError() != GL_NO_ERROR) {
icculus@7037
   549
        return SDL_SetError("Failed to update texture");
slouken@5201
   550
    }
slouken@5201
   551
    return 0;
slouken@5201
   552
}
slouken@5201
   553
slouken@6246
   554
static int
slouken@6247
   555
GLES2_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture)
slouken@6246
   556
{
slouken@6246
   557
    GLES2_DriverContext *data = (GLES2_DriverContext *) renderer->driverdata;
slouken@6246
   558
    GLES2_TextureData *texturedata = NULL;
slouken@6246
   559
    GLenum status;
slouken@6246
   560
slouken@6246
   561
    if (texture == NULL) {
slouken@6271
   562
        data->glBindFramebuffer(GL_FRAMEBUFFER, data->window_framebuffer);
slouken@6246
   563
    } else {
slouken@6246
   564
        texturedata = (GLES2_TextureData *) texture->driverdata;
slouken@6246
   565
        data->glBindFramebuffer(GL_FRAMEBUFFER, texturedata->fbo->FBO);
slouken@6246
   566
        /* TODO: check if texture pixel format allows this operation */
slouken@6246
   567
        data->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texturedata->texture_type, texturedata->texture, 0);
slouken@6246
   568
        /* Check FBO status */
slouken@6246
   569
        status = data->glCheckFramebufferStatus(GL_FRAMEBUFFER);
slouken@6246
   570
        if (status != GL_FRAMEBUFFER_COMPLETE) {
icculus@7037
   571
            return SDL_SetError("glFramebufferTexture2D() failed");
slouken@6246
   572
        }
slouken@6246
   573
    }
slouken@6246
   574
    return 0;
slouken@6246
   575
}
slouken@6246
   576
slouken@5201
   577
/*************************************************************************************************
slouken@5201
   578
 * Shader management functions                                                                   *
slouken@5201
   579
 *************************************************************************************************/
slouken@5201
   580
slouken@5201
   581
static GLES2_ShaderCacheEntry *GLES2_CacheShader(SDL_Renderer *renderer, GLES2_ShaderType type,
slouken@5201
   582
                                                 SDL_BlendMode blendMode);
slouken@5201
   583
static void GLES2_EvictShader(SDL_Renderer *renderer, GLES2_ShaderCacheEntry *entry);
slouken@5201
   584
static GLES2_ProgramCacheEntry *GLES2_CacheProgram(SDL_Renderer *renderer,
slouken@5201
   585
                                                   GLES2_ShaderCacheEntry *vertex,
slouken@5201
   586
                                                   GLES2_ShaderCacheEntry *fragment,
slouken@5201
   587
                                                   SDL_BlendMode blendMode);
slouken@5201
   588
static int GLES2_SelectProgram(SDL_Renderer *renderer, GLES2_ImageSource source,
slouken@5201
   589
                               SDL_BlendMode blendMode);
slouken@5201
   590
slouken@5201
   591
static GLES2_ProgramCacheEntry *
slouken@5201
   592
GLES2_CacheProgram(SDL_Renderer *renderer, GLES2_ShaderCacheEntry *vertex,
slouken@5201
   593
                   GLES2_ShaderCacheEntry *fragment, SDL_BlendMode blendMode)
slouken@5201
   594
{
slouken@5201
   595
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   596
    GLES2_ProgramCacheEntry *entry;
slouken@5201
   597
    GLES2_ShaderCacheEntry *shaderEntry;
slouken@5201
   598
    GLint linkSuccessful;
slouken@5201
   599
slouken@5201
   600
    /* Check if we've already cached this program */
slouken@5201
   601
    entry = rdata->program_cache.head;
slouken@5201
   602
    while (entry)
slouken@5201
   603
    {
slouken@5201
   604
        if (entry->vertex_shader == vertex && entry->fragment_shader == fragment)
slouken@5201
   605
            break;
slouken@5201
   606
        entry = entry->next;
slouken@5201
   607
    }
slouken@5201
   608
    if (entry)
slouken@5201
   609
    {
slouken@6061
   610
        if (rdata->program_cache.head != entry)
slouken@5201
   611
        {
slouken@5201
   612
            if (entry->next)
slouken@5201
   613
                entry->next->prev = entry->prev;
slouken@5201
   614
            if (entry->prev)
slouken@5201
   615
                entry->prev->next = entry->next;
slouken@5201
   616
            entry->prev = NULL;
slouken@5201
   617
            entry->next = rdata->program_cache.head;
slouken@5201
   618
            rdata->program_cache.head->prev = entry;
slouken@5201
   619
            rdata->program_cache.head = entry;
slouken@5201
   620
        }
slouken@5201
   621
        return entry;
slouken@5201
   622
    }
slouken@5201
   623
slouken@5201
   624
    /* Create a program cache entry */
slouken@5201
   625
    entry = (GLES2_ProgramCacheEntry *)SDL_calloc(1, sizeof(GLES2_ProgramCacheEntry));
slouken@5201
   626
    if (!entry)
slouken@5201
   627
    {
slouken@5201
   628
        SDL_OutOfMemory();
slouken@5201
   629
        return NULL;
slouken@5201
   630
    }
slouken@5201
   631
    entry->vertex_shader = vertex;
slouken@5201
   632
    entry->fragment_shader = fragment;
slouken@5201
   633
    entry->blend_mode = blendMode;
slouken@6232
   634
slouken@5201
   635
    /* Create the program and link it */
slouken@6188
   636
    rdata->glGetError();
slouken@6188
   637
    entry->id = rdata->glCreateProgram();
slouken@6188
   638
    rdata->glAttachShader(entry->id, vertex->id);
slouken@6188
   639
    rdata->glAttachShader(entry->id, fragment->id);
slouken@6188
   640
    rdata->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_POSITION, "a_position");
slouken@6188
   641
    rdata->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_TEXCOORD, "a_texCoord");
gabomdq@6320
   642
    rdata->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_ANGLE, "a_angle");
gabomdq@6320
   643
    rdata->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_CENTER, "a_center");
slouken@6188
   644
    rdata->glLinkProgram(entry->id);
slouken@6188
   645
    rdata->glGetProgramiv(entry->id, GL_LINK_STATUS, &linkSuccessful);
slouken@6188
   646
    if (rdata->glGetError() != GL_NO_ERROR || !linkSuccessful)
slouken@5201
   647
    {
slouken@6188
   648
        rdata->glDeleteProgram(entry->id);
slouken@5201
   649
        SDL_free(entry);
icculus@7037
   650
        SDL_SetError("Failed to link shader program");
slouken@5201
   651
        return NULL;
slouken@5201
   652
    }
slouken@6232
   653
slouken@5201
   654
    /* Predetermine locations of uniform variables */
slouken@5201
   655
    entry->uniform_locations[GLES2_UNIFORM_PROJECTION] =
slouken@6188
   656
        rdata->glGetUniformLocation(entry->id, "u_projection");
slouken@5201
   657
    entry->uniform_locations[GLES2_UNIFORM_TEXTURE] =
slouken@6188
   658
        rdata->glGetUniformLocation(entry->id, "u_texture");
slouken@5201
   659
    entry->uniform_locations[GLES2_UNIFORM_MODULATION] =
slouken@6188
   660
        rdata->glGetUniformLocation(entry->id, "u_modulation");
slouken@5201
   661
    entry->uniform_locations[GLES2_UNIFORM_COLOR] =
slouken@6188
   662
        rdata->glGetUniformLocation(entry->id, "u_color");
slouken@5201
   663
    entry->uniform_locations[GLES2_UNIFORM_COLORTABLE] =
slouken@6188
   664
        rdata->glGetUniformLocation(entry->id, "u_colorTable");
slouken@5201
   665
slouken@5201
   666
    /* Cache the linked program */
slouken@5201
   667
    if (rdata->program_cache.head)
slouken@5201
   668
    {
slouken@5201
   669
        entry->next = rdata->program_cache.head;
slouken@5201
   670
        rdata->program_cache.head->prev = entry;
slouken@5201
   671
    }
slouken@5201
   672
    else
slouken@5201
   673
    {
slouken@5201
   674
        rdata->program_cache.tail = entry;
slouken@5201
   675
    }
slouken@5201
   676
    rdata->program_cache.head = entry;
slouken@5201
   677
    ++rdata->program_cache.count;
slouken@5201
   678
slouken@5201
   679
    /* Increment the refcount of the shaders we're using */
slouken@5201
   680
    ++vertex->references;
slouken@5201
   681
    ++fragment->references;
slouken@5201
   682
slouken@5201
   683
    /* Evict the last entry from the cache if we exceed the limit */
slouken@5201
   684
    if (rdata->program_cache.count > GLES2_MAX_CACHED_PROGRAMS)
slouken@5201
   685
    {
slouken@5201
   686
        shaderEntry = rdata->program_cache.tail->vertex_shader;
slouken@5201
   687
        if (--shaderEntry->references <= 0)
slouken@5201
   688
            GLES2_EvictShader(renderer, shaderEntry);
slouken@5201
   689
        shaderEntry = rdata->program_cache.tail->fragment_shader;
slouken@5201
   690
        if (--shaderEntry->references <= 0)
slouken@5201
   691
            GLES2_EvictShader(renderer, shaderEntry);
slouken@6188
   692
        rdata->glDeleteProgram(rdata->program_cache.tail->id);
slouken@5201
   693
        rdata->program_cache.tail = rdata->program_cache.tail->prev;
slouken@5201
   694
        SDL_free(rdata->program_cache.tail->next);
slouken@5201
   695
        rdata->program_cache.tail->next = NULL;
slouken@5201
   696
        --rdata->program_cache.count;
slouken@5201
   697
    }
slouken@5201
   698
    return entry;
slouken@5201
   699
}
slouken@5201
   700
slouken@5201
   701
static GLES2_ShaderCacheEntry *
slouken@5201
   702
GLES2_CacheShader(SDL_Renderer *renderer, GLES2_ShaderType type, SDL_BlendMode blendMode)
slouken@5201
   703
{
slouken@5201
   704
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   705
    const GLES2_Shader *shader;
slouken@5201
   706
    const GLES2_ShaderInstance *instance = NULL;
slouken@5201
   707
    GLES2_ShaderCacheEntry *entry = NULL;
slouken@5201
   708
    GLint compileSuccessful = GL_FALSE;
slouken@5201
   709
    int i, j;
slouken@5201
   710
slouken@5201
   711
    /* Find the corresponding shader */
slouken@5201
   712
    shader = GLES2_GetShader(type, blendMode);
slouken@5201
   713
    if (!shader)
slouken@5201
   714
    {
slouken@5201
   715
        SDL_SetError("No shader matching the requested characteristics was found");
slouken@5201
   716
        return NULL;
slouken@5201
   717
    }
slouken@6232
   718
slouken@5201
   719
    /* Find a matching shader instance that's supported on this hardware */
slouken@5206
   720
    for (i = 0; i < shader->instance_count && !instance; ++i)
slouken@5201
   721
    {
slouken@5206
   722
        for (j = 0; j < rdata->shader_format_count && !instance; ++j)
slouken@5201
   723
        {
slouken@5201
   724
            if (!shader->instances)
slouken@5201
   725
                continue;
slouken@5206
   726
            if (!shader->instances[i])
slouken@5206
   727
                continue;
slouken@5201
   728
            if (shader->instances[i]->format != rdata->shader_formats[j])
slouken@5201
   729
                continue;
slouken@5201
   730
            instance = shader->instances[i];
slouken@5201
   731
        }
slouken@5201
   732
    }
slouken@5201
   733
    if (!instance)
slouken@5201
   734
    {
slouken@5201
   735
        SDL_SetError("The specified shader cannot be loaded on the current platform");
slouken@5201
   736
        return NULL;
slouken@5201
   737
    }
slouken@5201
   738
slouken@5201
   739
    /* Check if we've already cached this shader */
slouken@5201
   740
    entry = rdata->shader_cache.head;
slouken@5201
   741
    while (entry)
slouken@5201
   742
    {
slouken@5201
   743
        if (entry->instance == instance)
slouken@5201
   744
            break;
slouken@5201
   745
        entry = entry->next;
slouken@5201
   746
    }
slouken@5201
   747
    if (entry)
slouken@5201
   748
        return entry;
slouken@5201
   749
slouken@5201
   750
    /* Create a shader cache entry */
slouken@5201
   751
    entry = (GLES2_ShaderCacheEntry *)SDL_calloc(1, sizeof(GLES2_ShaderCacheEntry));
slouken@5201
   752
    if (!entry)
slouken@5201
   753
    {
slouken@5201
   754
        SDL_OutOfMemory();
slouken@5201
   755
        return NULL;
slouken@5201
   756
    }
slouken@5201
   757
    entry->type = type;
slouken@5201
   758
    entry->instance = instance;
slouken@5201
   759
slouken@5201
   760
    /* Compile or load the selected shader instance */
slouken@6188
   761
    rdata->glGetError();
slouken@6188
   762
    entry->id = rdata->glCreateShader(instance->type);
slouken@5201
   763
    if (instance->format == (GLenum)-1)
slouken@5201
   764
    {
slouken@6188
   765
        rdata->glShaderSource(entry->id, 1, (const char **)&instance->data, NULL);
slouken@6188
   766
        rdata->glCompileShader(entry->id);
slouken@6188
   767
        rdata->glGetShaderiv(entry->id, GL_COMPILE_STATUS, &compileSuccessful);
slouken@5201
   768
    }
slouken@5201
   769
    else
slouken@5201
   770
    {
slouken@6188
   771
        rdata->glShaderBinary(1, &entry->id, instance->format, instance->data, instance->length);
slouken@5201
   772
        compileSuccessful = GL_TRUE;
slouken@5201
   773
    }
slouken@6188
   774
    if (rdata->glGetError() != GL_NO_ERROR || !compileSuccessful)
slouken@5201
   775
    {
slouken@5212
   776
        char *info = NULL;
slouken@6113
   777
        int length = 0;
slouken@5212
   778
slouken@6188
   779
        rdata->glGetShaderiv(entry->id, GL_INFO_LOG_LENGTH, &length);
slouken@5212
   780
        if (length > 0) {
slouken@5212
   781
            info = SDL_stack_alloc(char, length);
slouken@5212
   782
            if (info) {
slouken@6188
   783
                rdata->glGetShaderInfoLog(entry->id, length, &length, info);
slouken@5212
   784
            }
slouken@5212
   785
        }
slouken@5212
   786
        if (info) {
slouken@5212
   787
            SDL_SetError("Failed to load the shader: %s", info);
slouken@5212
   788
            SDL_stack_free(info);
slouken@5212
   789
        } else {
slouken@5212
   790
            SDL_SetError("Failed to load the shader");
slouken@5212
   791
        }
slouken@6188
   792
        rdata->glDeleteShader(entry->id);
slouken@5201
   793
        SDL_free(entry);
slouken@5201
   794
        return NULL;
slouken@5201
   795
    }
slouken@5201
   796
slouken@5201
   797
    /* Link the shader entry in at the front of the cache */
slouken@5201
   798
    if (rdata->shader_cache.head)
slouken@5201
   799
    {
slouken@5201
   800
        entry->next = rdata->shader_cache.head;
slouken@5201
   801
        rdata->shader_cache.head->prev = entry;
slouken@5201
   802
    }
slouken@5201
   803
    rdata->shader_cache.head = entry;
slouken@5201
   804
    ++rdata->shader_cache.count;
slouken@5201
   805
    return entry;
slouken@5201
   806
}
slouken@5201
   807
slouken@5201
   808
static void
slouken@5201
   809
GLES2_EvictShader(SDL_Renderer *renderer, GLES2_ShaderCacheEntry *entry)
slouken@5201
   810
{
slouken@5201
   811
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   812
slouken@5201
   813
    /* Unlink the shader from the cache */
slouken@5201
   814
    if (entry->next)
slouken@5201
   815
        entry->next->prev = entry->prev;
slouken@5201
   816
    if (entry->prev)
slouken@5201
   817
        entry->prev->next = entry->next;
slouken@5201
   818
    if (rdata->shader_cache.head == entry)
slouken@5201
   819
        rdata->shader_cache.head = entry->next;
slouken@5201
   820
    --rdata->shader_cache.count;
slouken@5201
   821
slouken@5201
   822
    /* Deallocate the shader */
slouken@6188
   823
    rdata->glDeleteShader(entry->id);
slouken@5201
   824
    SDL_free(entry);
slouken@5201
   825
}
slouken@5201
   826
slouken@5201
   827
static int
slouken@5201
   828
GLES2_SelectProgram(SDL_Renderer *renderer, GLES2_ImageSource source, SDL_BlendMode blendMode)
slouken@5201
   829
{
slouken@5201
   830
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   831
    GLES2_ShaderCacheEntry *vertex = NULL;
slouken@5201
   832
    GLES2_ShaderCacheEntry *fragment = NULL;
slouken@5201
   833
    GLES2_ShaderType vtype, ftype;
slouken@5201
   834
    GLES2_ProgramCacheEntry *program;
slouken@5201
   835
slouken@5201
   836
    /* Select an appropriate shader pair for the specified modes */
slouken@5201
   837
    vtype = GLES2_SHADER_VERTEX_DEFAULT;
slouken@5201
   838
    switch (source)
slouken@5201
   839
    {
slouken@5201
   840
    case GLES2_IMAGESOURCE_SOLID:
slouken@5201
   841
        ftype = GLES2_SHADER_FRAGMENT_SOLID_SRC;
slouken@5201
   842
        break;
slouken@6113
   843
    case GLES2_IMAGESOURCE_TEXTURE_ABGR:
slouken@6113
   844
        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_ABGR_SRC;
slouken@6341
   845
        break;
slouken@6113
   846
    case GLES2_IMAGESOURCE_TEXTURE_ARGB:
slouken@6113
   847
        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_ARGB_SRC;
slouken@5201
   848
        break;
slouken@6113
   849
    case GLES2_IMAGESOURCE_TEXTURE_RGB:
slouken@6113
   850
        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_RGB_SRC;
slouken@6113
   851
        break;
slouken@6113
   852
    case GLES2_IMAGESOURCE_TEXTURE_BGR:
slouken@6113
   853
        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_BGR_SRC;
slouken@6113
   854
        break;
slouken@6113
   855
    default:
slouken@6113
   856
        goto fault;
slouken@5201
   857
    }
slouken@5201
   858
slouken@5201
   859
    /* Load the requested shaders */
slouken@5201
   860
    vertex = GLES2_CacheShader(renderer, vtype, blendMode);
slouken@5201
   861
    if (!vertex)
slouken@5201
   862
        goto fault;
slouken@5201
   863
    fragment = GLES2_CacheShader(renderer, ftype, blendMode);
slouken@5201
   864
    if (!fragment)
slouken@5201
   865
        goto fault;
slouken@5201
   866
slouken@5201
   867
    /* Check if we need to change programs at all */
slouken@5201
   868
    if (rdata->current_program &&
slouken@5201
   869
        rdata->current_program->vertex_shader == vertex &&
slouken@5201
   870
        rdata->current_program->fragment_shader == fragment)
slouken@5201
   871
        return 0;
slouken@5201
   872
slouken@5201
   873
    /* Generate a matching program */
slouken@5201
   874
    program = GLES2_CacheProgram(renderer, vertex, fragment, blendMode);
slouken@5201
   875
    if (!program)
slouken@5201
   876
        goto fault;
slouken@5201
   877
slouken@5201
   878
    /* Select that program in OpenGL */
slouken@6188
   879
    rdata->glGetError();
slouken@6188
   880
    rdata->glUseProgram(program->id);
slouken@6188
   881
    if (rdata->glGetError() != GL_NO_ERROR)
slouken@5201
   882
    {
slouken@5201
   883
        SDL_SetError("Failed to select program");
slouken@5201
   884
        goto fault;
slouken@5201
   885
    }
slouken@5201
   886
slouken@5201
   887
    /* Set the current program */
slouken@5201
   888
    rdata->current_program = program;
slouken@5201
   889
slouken@5201
   890
    /* Activate an orthographic projection */
slouken@5201
   891
    if (GLES2_SetOrthographicProjection(renderer) < 0)
slouken@5201
   892
        goto fault;
slouken@5201
   893
slouken@5201
   894
    /* Clean up and return */
slouken@5201
   895
    return 0;
slouken@5201
   896
fault:
slouken@5201
   897
    if (vertex && vertex->references <= 0)
slouken@5201
   898
        GLES2_EvictShader(renderer, vertex);
slouken@5201
   899
    if (fragment && fragment->references <= 0)
slouken@5201
   900
        GLES2_EvictShader(renderer, fragment);
slouken@5201
   901
    rdata->current_program = NULL;
slouken@5201
   902
    return -1;
slouken@5201
   903
}
slouken@5201
   904
slouken@5201
   905
static int
slouken@5201
   906
GLES2_SetOrthographicProjection(SDL_Renderer *renderer)
slouken@5201
   907
{
slouken@5201
   908
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   909
    GLfloat projection[4][4];
slouken@5201
   910
    GLuint locProjection;
slouken@5201
   911
slouken@7239
   912
    if (!renderer->viewport.w || !renderer->viewport.h) {
slouken@7239
   913
        return 0;
slouken@7239
   914
    }
slouken@7239
   915
slouken@5201
   916
    /* Prepare an orthographic projection */
slouken@5297
   917
    projection[0][0] = 2.0f / renderer->viewport.w;
slouken@5201
   918
    projection[0][1] = 0.0f;
slouken@5201
   919
    projection[0][2] = 0.0f;
slouken@5201
   920
    projection[0][3] = 0.0f;
slouken@5201
   921
    projection[1][0] = 0.0f;
slouken@6341
   922
    if (renderer->target) {
slouken@6341
   923
        projection[1][1] = 2.0f / renderer->viewport.h;
slouken@6341
   924
    } else {
slouken@6341
   925
        projection[1][1] = -2.0f / renderer->viewport.h;
slouken@6341
   926
    }
slouken@5201
   927
    projection[1][2] = 0.0f;
slouken@5201
   928
    projection[1][3] = 0.0f;
slouken@5201
   929
    projection[2][0] = 0.0f;
slouken@5201
   930
    projection[2][1] = 0.0f;
slouken@6341
   931
    projection[2][2] = 0.0f;
slouken@5201
   932
    projection[2][3] = 0.0f;
slouken@5201
   933
    projection[3][0] = -1.0f;
slouken@6341
   934
    if (renderer->target) {
slouken@6341
   935
        projection[3][1] = -1.0f;
slouken@6341
   936
    } else {
slouken@6341
   937
        projection[3][1] = 1.0f;
slouken@6341
   938
    }
slouken@5201
   939
    projection[3][2] = 0.0f;
slouken@5201
   940
    projection[3][3] = 1.0f;
slouken@5201
   941
slouken@5201
   942
    /* Set the projection matrix */
slouken@5201
   943
    locProjection = rdata->current_program->uniform_locations[GLES2_UNIFORM_PROJECTION];
slouken@6188
   944
    rdata->glGetError();
slouken@6188
   945
    rdata->glUniformMatrix4fv(locProjection, 1, GL_FALSE, (GLfloat *)projection);
icculus@7037
   946
    if (rdata->glGetError() != GL_NO_ERROR) {
icculus@7037
   947
        return SDL_SetError("Failed to set orthographic projection");
slouken@5201
   948
    }
slouken@5201
   949
    return 0;
slouken@5201
   950
}
slouken@5201
   951
slouken@5201
   952
/*************************************************************************************************
slouken@5201
   953
 * Rendering functions                                                                           *
slouken@5201
   954
 *************************************************************************************************/
slouken@5201
   955
slouken@5224
   956
static const float inv255f = 1.0f / 255.0f;
slouken@5224
   957
slouken@5201
   958
static int GLES2_RenderClear(SDL_Renderer *renderer);
slouken@6528
   959
static int GLES2_RenderDrawPoints(SDL_Renderer *renderer, const SDL_FPoint *points, int count);
slouken@6528
   960
static int GLES2_RenderDrawLines(SDL_Renderer *renderer, const SDL_FPoint *points, int count);
slouken@6528
   961
static int GLES2_RenderFillRects(SDL_Renderer *renderer, const SDL_FRect *rects, int count);
slouken@5201
   962
static int GLES2_RenderCopy(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect,
slouken@6528
   963
                            const SDL_FRect *dstrect);
gabomdq@6320
   964
static int GLES2_RenderCopyEx(SDL_Renderer * renderer, SDL_Texture * texture,
slouken@6528
   965
                         const SDL_Rect * srcrect, const SDL_FRect * dstrect,
slouken@6528
   966
                         const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip);
slouken@7141
   967
static int GLES2_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
slouken@7141
   968
                    Uint32 pixel_format, void * pixels, int pitch);
slouken@5201
   969
static void GLES2_RenderPresent(SDL_Renderer *renderer);
slouken@5201
   970
slouken@5333
   971
slouken@5201
   972
static int
slouken@5333
   973
GLES2_RenderClear(SDL_Renderer * renderer)
slouken@5201
   974
{
slouken@6188
   975
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@6188
   976
slouken@5201
   977
    GLES2_ActivateRenderer(renderer);
slouken@6232
   978
slouken@6188
   979
    rdata->glClearColor((GLfloat) renderer->r * inv255f,
slouken@5333
   980
                 (GLfloat) renderer->g * inv255f,
slouken@5333
   981
                 (GLfloat) renderer->b * inv255f,
slouken@5333
   982
                 (GLfloat) renderer->a * inv255f);
slouken@5333
   983
slouken@6188
   984
    rdata->glClear(GL_COLOR_BUFFER_BIT);
slouken@5333
   985
slouken@5201
   986
    return 0;
slouken@5201
   987
}
slouken@5201
   988
slouken@5201
   989
static void
slouken@5355
   990
GLES2_SetBlendMode(GLES2_DriverContext *rdata, int blendMode)
slouken@5201
   991
{
slouken@5355
   992
    if (blendMode != rdata->current.blendMode) {
slouken@5355
   993
        switch (blendMode) {
slouken@5355
   994
        default:
slouken@5355
   995
        case SDL_BLENDMODE_NONE:
slouken@6188
   996
            rdata->glDisable(GL_BLEND);
slouken@5355
   997
            break;
slouken@5355
   998
        case SDL_BLENDMODE_BLEND:
slouken@6188
   999
            rdata->glEnable(GL_BLEND);
slouken@7502
  1000
            rdata->glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
slouken@5355
  1001
            break;
slouken@5355
  1002
        case SDL_BLENDMODE_ADD:
slouken@6188
  1003
            rdata->glEnable(GL_BLEND);
slouken@7502
  1004
            rdata->glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE, GL_ZERO, GL_ONE);
slouken@5355
  1005
            break;
slouken@5355
  1006
        case SDL_BLENDMODE_MOD:
slouken@6188
  1007
            rdata->glEnable(GL_BLEND);
slouken@7502
  1008
            rdata->glBlendFuncSeparate(GL_ZERO, GL_SRC_COLOR, GL_ZERO, GL_ONE);
slouken@5355
  1009
            break;
slouken@5355
  1010
        }
slouken@5355
  1011
        rdata->current.blendMode = blendMode;
slouken@5201
  1012
    }
slouken@5201
  1013
}
slouken@5201
  1014
slouken@5355
  1015
static void
slouken@5355
  1016
GLES2_SetTexCoords(GLES2_DriverContext * rdata, SDL_bool enabled)
slouken@5355
  1017
{
slouken@5355
  1018
    if (enabled != rdata->current.tex_coords) {
slouken@5355
  1019
        if (enabled) {
slouken@6188
  1020
            rdata->glEnableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
slouken@5355
  1021
        } else {
slouken@6188
  1022
            rdata->glDisableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
slouken@5355
  1023
        }
slouken@5355
  1024
        rdata->current.tex_coords = enabled;
slouken@5355
  1025
    }
slouken@5355
  1026
}
slouken@5355
  1027
slouken@5355
  1028
static int
slouken@5355
  1029
GLES2_SetDrawingState(SDL_Renderer * renderer)
slouken@5355
  1030
{
slouken@5355
  1031
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5355
  1032
    int blendMode = renderer->blendMode;
slouken@5355
  1033
    GLuint locColor;
slouken@5355
  1034
slouken@6188
  1035
    rdata->glGetError();
slouken@5355
  1036
slouken@5355
  1037
    GLES2_ActivateRenderer(renderer);
slouken@5355
  1038
slouken@5355
  1039
    GLES2_SetBlendMode(rdata, blendMode);
slouken@5355
  1040
slouken@5355
  1041
    GLES2_SetTexCoords(rdata, SDL_FALSE);
slouken@5355
  1042
slouken@5355
  1043
    /* Activate an appropriate shader and set the projection matrix */
slouken@5355
  1044
    if (GLES2_SelectProgram(renderer, GLES2_IMAGESOURCE_SOLID, blendMode) < 0)
slouken@5355
  1045
        return -1;
slouken@5355
  1046
slouken@5355
  1047
    /* Select the color to draw with */
slouken@5355
  1048
    locColor = rdata->current_program->uniform_locations[GLES2_UNIFORM_COLOR];
slouken@6341
  1049
    if (renderer->target &&
slouken@6341
  1050
        (renderer->target->format == SDL_PIXELFORMAT_ARGB8888 ||
slouken@6341
  1051
         renderer->target->format == SDL_PIXELFORMAT_RGB888)) {
slouken@6341
  1052
        rdata->glUniform4f(locColor,
slouken@6341
  1053
                    renderer->b * inv255f,
slouken@6341
  1054
                    renderer->g * inv255f,
slouken@6341
  1055
                    renderer->r * inv255f,
slouken@6341
  1056
                    renderer->a * inv255f);
slouken@6341
  1057
    } else {
slouken@6341
  1058
        rdata->glUniform4f(locColor,
slouken@6341
  1059
                    renderer->r * inv255f,
slouken@6341
  1060
                    renderer->g * inv255f,
slouken@6341
  1061
                    renderer->b * inv255f,
slouken@6341
  1062
                    renderer->a * inv255f);
slouken@6341
  1063
    }
slouken@5355
  1064
    return 0;
slouken@5355
  1065
}
slouken@5355
  1066
slouken@5201
  1067
static int
slouken@6528
  1068
GLES2_RenderDrawPoints(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
slouken@5201
  1069
{
slouken@6188
  1070
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
  1071
    GLfloat *vertices;
slouken@5201
  1072
    int idx;
slouken@5201
  1073
slouken@5355
  1074
    if (GLES2_SetDrawingState(renderer) < 0) {
slouken@5201
  1075
        return -1;
slouken@5355
  1076
    }
slouken@5201
  1077
slouken@5201
  1078
    /* Emit the specified vertices as points */
slouken@5201
  1079
    vertices = SDL_stack_alloc(GLfloat, count * 2);
icculus@7037
  1080
    for (idx = 0; idx < count; ++idx) {
slouken@6528
  1081
        GLfloat x = points[idx].x + 0.5f;
slouken@6528
  1082
        GLfloat y = points[idx].y + 0.5f;
slouken@5201
  1083
slouken@5201
  1084
        vertices[idx * 2] = x;
slouken@5201
  1085
        vertices[(idx * 2) + 1] = y;
slouken@5201
  1086
    }
slouken@6188
  1087
    rdata->glGetError();
slouken@6188
  1088
    rdata->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
slouken@6188
  1089
    rdata->glDrawArrays(GL_POINTS, 0, count);
slouken@5201
  1090
    SDL_stack_free(vertices);
icculus@7037
  1091
    if (rdata->glGetError() != GL_NO_ERROR) {
slouken@7571
  1092
        return SDL_SetError("Failed to render points");
slouken@5201
  1093
    }
slouken@5201
  1094
    return 0;
slouken@5201
  1095
}
slouken@5201
  1096
slouken@5201
  1097
static int
slouken@6528
  1098
GLES2_RenderDrawLines(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
slouken@5201
  1099
{
slouken@6188
  1100
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
  1101
    GLfloat *vertices;
slouken@5201
  1102
    int idx;
slouken@5201
  1103
slouken@5355
  1104
    if (GLES2_SetDrawingState(renderer) < 0) {
slouken@5201
  1105
        return -1;
slouken@5355
  1106
    }
slouken@5201
  1107
slouken@5201
  1108
    /* Emit a line strip including the specified vertices */
slouken@5201
  1109
    vertices = SDL_stack_alloc(GLfloat, count * 2);
icculus@7037
  1110
    for (idx = 0; idx < count; ++idx) {
slouken@6528
  1111
        GLfloat x = points[idx].x + 0.5f;
slouken@6528
  1112
        GLfloat y = points[idx].y + 0.5f;
slouken@5201
  1113
slouken@5201
  1114
        vertices[idx * 2] = x;
slouken@5201
  1115
        vertices[(idx * 2) + 1] = y;
slouken@5201
  1116
    }
slouken@6188
  1117
    rdata->glGetError();
slouken@6188
  1118
    rdata->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
slouken@6188
  1119
    rdata->glDrawArrays(GL_LINE_STRIP, 0, count);
slouken@6076
  1120
slouken@6076
  1121
    /* We need to close the endpoint of the line */
slouken@6076
  1122
    if (count == 2 ||
slouken@6076
  1123
        points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
slouken@6188
  1124
        rdata->glDrawArrays(GL_POINTS, count-1, 1);
slouken@6076
  1125
    }
slouken@5201
  1126
    SDL_stack_free(vertices);
icculus@7037
  1127
    if (rdata->glGetError() != GL_NO_ERROR) {
icculus@7037
  1128
        return SDL_SetError("Failed to render lines");
slouken@5201
  1129
    }
slouken@5201
  1130
    return 0;
slouken@5201
  1131
}
slouken@5201
  1132
slouken@5201
  1133
static int
slouken@6528
  1134
GLES2_RenderFillRects(SDL_Renderer *renderer, const SDL_FRect *rects, int count)
slouken@5201
  1135
{
slouken@6188
  1136
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
  1137
    GLfloat vertices[8];
slouken@5201
  1138
    int idx;
slouken@5201
  1139
slouken@5355
  1140
    if (GLES2_SetDrawingState(renderer) < 0) {
slouken@5201
  1141
        return -1;
slouken@5355
  1142
    }
slouken@5201
  1143
slouken@5201
  1144
    /* Emit a line loop for each rectangle */
slouken@6188
  1145
    rdata->glGetError();
slouken@5297
  1146
    for (idx = 0; idx < count; ++idx) {
slouken@6528
  1147
        const SDL_FRect *rect = &rects[idx];
slouken@5297
  1148
slouken@6528
  1149
        GLfloat xMin = rect->x;
slouken@6528
  1150
        GLfloat xMax = (rect->x + rect->w);
slouken@6528
  1151
        GLfloat yMin = rect->y;
slouken@6528
  1152
        GLfloat yMax = (rect->y + rect->h);
slouken@5201
  1153
slouken@5201
  1154
        vertices[0] = xMin;
slouken@5201
  1155
        vertices[1] = yMin;
slouken@5201
  1156
        vertices[2] = xMax;
slouken@5201
  1157
        vertices[3] = yMin;
slouken@5201
  1158
        vertices[4] = xMin;
slouken@5201
  1159
        vertices[5] = yMax;
slouken@5201
  1160
        vertices[6] = xMax;
slouken@5201
  1161
        vertices[7] = yMax;
slouken@6188
  1162
        rdata->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
slouken@6188
  1163
        rdata->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
slouken@5201
  1164
    }
icculus@7037
  1165
    if (rdata->glGetError() != GL_NO_ERROR) {
slouken@7571
  1166
        return SDL_SetError("Failed to render filled rects");
slouken@5201
  1167
    }
slouken@5201
  1168
    return 0;
slouken@5201
  1169
}
slouken@5201
  1170
slouken@5201
  1171
static int
slouken@5201
  1172
GLES2_RenderCopy(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect,
slouken@6528
  1173
                 const SDL_FRect *dstrect)
slouken@5201
  1174
{
slouken@5201
  1175
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
  1176
    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
gabomdq@7691
  1177
    GLES2_ImageSource sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
slouken@5201
  1178
    SDL_BlendMode blendMode;
slouken@5201
  1179
    GLfloat vertices[8];
slouken@5201
  1180
    GLfloat texCoords[8];
slouken@5201
  1181
    GLuint locTexture;
slouken@5201
  1182
    GLuint locModulation;
slouken@5201
  1183
slouken@5201
  1184
    GLES2_ActivateRenderer(renderer);
slouken@5201
  1185
slouken@5201
  1186
    /* Activate an appropriate shader and set the projection matrix */
slouken@5201
  1187
    blendMode = texture->blendMode;
slouken@6246
  1188
    if (renderer->target) {
slouken@6232
  1189
        /* Check if we need to do color mapping between the source and render target textures */
slouken@6246
  1190
        if (renderer->target->format != texture->format) {
slouken@6232
  1191
            switch (texture->format)
slouken@6232
  1192
            {
slouken@6232
  1193
            case SDL_PIXELFORMAT_ABGR8888:
slouken@6246
  1194
                switch (renderer->target->format)
slouken@6232
  1195
                {
slouken@6232
  1196
                    case SDL_PIXELFORMAT_ARGB8888:
slouken@6232
  1197
                    case SDL_PIXELFORMAT_RGB888:
slouken@6232
  1198
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
slouken@6232
  1199
                        break;
slouken@6232
  1200
                    case SDL_PIXELFORMAT_BGR888:
slouken@6232
  1201
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
slouken@6232
  1202
                        break;
slouken@6232
  1203
                }
slouken@6232
  1204
                break;
slouken@6232
  1205
            case SDL_PIXELFORMAT_ARGB8888:
slouken@6246
  1206
                switch (renderer->target->format)
slouken@6232
  1207
                {
slouken@6232
  1208
                    case SDL_PIXELFORMAT_ABGR8888:
slouken@6232
  1209
                    case SDL_PIXELFORMAT_BGR888:
slouken@6232
  1210
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
slouken@6232
  1211
                        break;
slouken@6232
  1212
                    case SDL_PIXELFORMAT_RGB888:
slouken@6232
  1213
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
slouken@6232
  1214
                        break;
slouken@6232
  1215
                }
slouken@6232
  1216
                break;
slouken@6232
  1217
            case SDL_PIXELFORMAT_BGR888:
slouken@6246
  1218
                switch (renderer->target->format)
slouken@6232
  1219
                {
slouken@6232
  1220
                    case SDL_PIXELFORMAT_ABGR8888:
slouken@6232
  1221
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
slouken@6232
  1222
                        break;
slouken@6232
  1223
                    case SDL_PIXELFORMAT_ARGB8888:
slouken@6232
  1224
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_RGB;
slouken@6232
  1225
                        break;
slouken@6232
  1226
                    case SDL_PIXELFORMAT_RGB888:
slouken@6232
  1227
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
slouken@6232
  1228
                        break;
slouken@6232
  1229
                }
slouken@6232
  1230
                break;
slouken@6232
  1231
            case SDL_PIXELFORMAT_RGB888:
slouken@6246
  1232
                switch (renderer->target->format)
slouken@6232
  1233
                {
slouken@6232
  1234
                    case SDL_PIXELFORMAT_ABGR8888:
slouken@6232
  1235
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
slouken@6232
  1236
                        break;
slouken@6232
  1237
                    case SDL_PIXELFORMAT_ARGB8888:
slouken@6232
  1238
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
slouken@6232
  1239
                        break;
slouken@6232
  1240
                    case SDL_PIXELFORMAT_BGR888:
slouken@6232
  1241
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
slouken@6232
  1242
                        break;
slouken@6232
  1243
                }
slouken@6232
  1244
                break;
slouken@6232
  1245
            }
slouken@6232
  1246
        }
slouken@7191
  1247
        else sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;   /* Texture formats match, use the non color mapping shader (even if the formats are not ABGR) */
slouken@6232
  1248
    }
slouken@6232
  1249
    else {
slouken@6232
  1250
        switch (texture->format)
slouken@6232
  1251
        {
slouken@6232
  1252
            case SDL_PIXELFORMAT_ABGR8888:
slouken@6232
  1253
                sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
slouken@6232
  1254
                break;
slouken@6232
  1255
            case SDL_PIXELFORMAT_ARGB8888:
slouken@6232
  1256
                sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
slouken@6232
  1257
                break;
slouken@6232
  1258
            case SDL_PIXELFORMAT_BGR888:
slouken@6232
  1259
                sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
slouken@6232
  1260
                break;
slouken@6232
  1261
            case SDL_PIXELFORMAT_RGB888:
slouken@6232
  1262
                sourceType = GLES2_IMAGESOURCE_TEXTURE_RGB;
slouken@6232
  1263
                break;
slouken@6928
  1264
            default:
slouken@6928
  1265
                return -1;
slouken@6232
  1266
        }
slouken@6113
  1267
    }
slouken@5201
  1268
    if (GLES2_SelectProgram(renderer, sourceType, blendMode) < 0)
slouken@5201
  1269
        return -1;
slouken@5201
  1270
slouken@5201
  1271
    /* Select the target texture */
slouken@5201
  1272
    locTexture = rdata->current_program->uniform_locations[GLES2_UNIFORM_TEXTURE];
slouken@6188
  1273
    rdata->glGetError();
slouken@6341
  1274
    rdata->glActiveTexture(GL_TEXTURE0);
gabomdq@6320
  1275
    rdata->glBindTexture(tdata->texture_type, tdata->texture);
gabomdq@6320
  1276
    rdata->glUniform1i(locTexture, 0);
gabomdq@6320
  1277
gabomdq@6320
  1278
    /* Configure color modulation */
gabomdq@6320
  1279
    locModulation = rdata->current_program->uniform_locations[GLES2_UNIFORM_MODULATION];
slouken@6341
  1280
    if (renderer->target &&
slouken@6341
  1281
        (renderer->target->format == SDL_PIXELFORMAT_ARGB8888 ||
slouken@6341
  1282
         renderer->target->format == SDL_PIXELFORMAT_RGB888)) {
slouken@6341
  1283
        rdata->glUniform4f(locModulation,
slouken@6341
  1284
                    texture->b * inv255f,
slouken@6341
  1285
                    texture->g * inv255f,
slouken@6341
  1286
                    texture->r * inv255f,
slouken@6341
  1287
                    texture->a * inv255f);
slouken@6341
  1288
    } else {
slouken@6341
  1289
        rdata->glUniform4f(locModulation,
slouken@6341
  1290
                    texture->r * inv255f,
slouken@6341
  1291
                    texture->g * inv255f,
slouken@6341
  1292
                    texture->b * inv255f,
slouken@6341
  1293
                    texture->a * inv255f);
slouken@6341
  1294
    }
gabomdq@6320
  1295
gabomdq@6320
  1296
    /* Configure texture blending */
gabomdq@6320
  1297
    GLES2_SetBlendMode(rdata, blendMode);
gabomdq@6320
  1298
gabomdq@6320
  1299
    GLES2_SetTexCoords(rdata, SDL_TRUE);
gabomdq@6320
  1300
gabomdq@6320
  1301
    /* Emit the textured quad */
slouken@6528
  1302
    vertices[0] = dstrect->x;
slouken@6528
  1303
    vertices[1] = dstrect->y;
slouken@6528
  1304
    vertices[2] = (dstrect->x + dstrect->w);
slouken@6528
  1305
    vertices[3] = dstrect->y;
slouken@6528
  1306
    vertices[4] = dstrect->x;
slouken@6528
  1307
    vertices[5] = (dstrect->y + dstrect->h);
slouken@6528
  1308
    vertices[6] = (dstrect->x + dstrect->w);
slouken@6528
  1309
    vertices[7] = (dstrect->y + dstrect->h);
gabomdq@6320
  1310
    rdata->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
gabomdq@6320
  1311
    texCoords[0] = srcrect->x / (GLfloat)texture->w;
gabomdq@6320
  1312
    texCoords[1] = srcrect->y / (GLfloat)texture->h;
gabomdq@6320
  1313
    texCoords[2] = (srcrect->x + srcrect->w) / (GLfloat)texture->w;
gabomdq@6320
  1314
    texCoords[3] = srcrect->y / (GLfloat)texture->h;
gabomdq@6320
  1315
    texCoords[4] = srcrect->x / (GLfloat)texture->w;
gabomdq@6320
  1316
    texCoords[5] = (srcrect->y + srcrect->h) / (GLfloat)texture->h;
gabomdq@6320
  1317
    texCoords[6] = (srcrect->x + srcrect->w) / (GLfloat)texture->w;
gabomdq@6320
  1318
    texCoords[7] = (srcrect->y + srcrect->h) / (GLfloat)texture->h;
gabomdq@6320
  1319
    rdata->glVertexAttribPointer(GLES2_ATTRIBUTE_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 0, texCoords);
gabomdq@6320
  1320
    rdata->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
icculus@7037
  1321
    if (rdata->glGetError() != GL_NO_ERROR) {
icculus@7037
  1322
        return SDL_SetError("Failed to render texture");
gabomdq@6320
  1323
    }
gabomdq@6320
  1324
    return 0;
gabomdq@6320
  1325
}
gabomdq@6320
  1326
gabomdq@6320
  1327
static int
gabomdq@6320
  1328
GLES2_RenderCopyEx(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect,
slouken@6528
  1329
                 const SDL_FRect *dstrect, const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
gabomdq@6320
  1330
{
gabomdq@6320
  1331
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
gabomdq@6320
  1332
    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
gabomdq@7691
  1333
    GLES2_ImageSource sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
gabomdq@6320
  1334
    SDL_BlendMode blendMode;
gabomdq@6320
  1335
    GLfloat vertices[8];
gabomdq@6320
  1336
    GLfloat texCoords[8];
gabomdq@6320
  1337
    GLuint locTexture;
gabomdq@6320
  1338
    GLuint locModulation;
gabomdq@6320
  1339
    GLfloat translate[8];
gabomdq@6320
  1340
    GLfloat fAngle[4];
gabomdq@6320
  1341
    GLfloat tmp;
gabomdq@6320
  1342
gabomdq@6320
  1343
    GLES2_ActivateRenderer(renderer);
slouken@7191
  1344
gabomdq@6320
  1345
    rdata->glEnableVertexAttribArray(GLES2_ATTRIBUTE_CENTER);
gabomdq@6320
  1346
    rdata->glEnableVertexAttribArray(GLES2_ATTRIBUTE_ANGLE);
slouken@6825
  1347
    fAngle[0] = fAngle[1] = fAngle[2] = fAngle[3] = (GLfloat)(360.0f - angle);
gabomdq@6320
  1348
    /* Calculate the center of rotation */
slouken@6528
  1349
    translate[0] = translate[2] = translate[4] = translate[6] = (center->x + dstrect->x);
slouken@6528
  1350
    translate[1] = translate[3] = translate[5] = translate[7] = (center->y + dstrect->y);
gabomdq@6320
  1351
gabomdq@6320
  1352
    /* Activate an appropriate shader and set the projection matrix */
gabomdq@6320
  1353
    blendMode = texture->blendMode;
gabomdq@6320
  1354
    if (renderer->target) {
gabomdq@6320
  1355
        /* Check if we need to do color mapping between the source and render target textures */
gabomdq@6320
  1356
        if (renderer->target->format != texture->format) {
gabomdq@6320
  1357
            switch (texture->format)
gabomdq@6320
  1358
            {
gabomdq@6320
  1359
            case SDL_PIXELFORMAT_ABGR8888:
gabomdq@6320
  1360
                switch (renderer->target->format)
gabomdq@6320
  1361
                {
gabomdq@6320
  1362
                    case SDL_PIXELFORMAT_ARGB8888:
gabomdq@6320
  1363
                    case SDL_PIXELFORMAT_RGB888:
gabomdq@6320
  1364
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
gabomdq@6320
  1365
                        break;
gabomdq@6320
  1366
                    case SDL_PIXELFORMAT_BGR888:
gabomdq@6320
  1367
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
gabomdq@6320
  1368
                        break;
gabomdq@6320
  1369
                }
gabomdq@6320
  1370
                break;
gabomdq@6320
  1371
            case SDL_PIXELFORMAT_ARGB8888:
gabomdq@6320
  1372
                switch (renderer->target->format)
gabomdq@6320
  1373
                {
gabomdq@6320
  1374
                    case SDL_PIXELFORMAT_ABGR8888:
gabomdq@6320
  1375
                    case SDL_PIXELFORMAT_BGR888:
gabomdq@6320
  1376
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
gabomdq@6320
  1377
                        break;
gabomdq@6320
  1378
                    case SDL_PIXELFORMAT_RGB888:
gabomdq@6320
  1379
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
gabomdq@6320
  1380
                        break;
gabomdq@6320
  1381
                }
gabomdq@6320
  1382
                break;
gabomdq@6320
  1383
            case SDL_PIXELFORMAT_BGR888:
gabomdq@6320
  1384
                switch (renderer->target->format)
gabomdq@6320
  1385
                {
gabomdq@6320
  1386
                    case SDL_PIXELFORMAT_ABGR8888:
gabomdq@6320
  1387
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
gabomdq@6320
  1388
                        break;
gabomdq@6320
  1389
                    case SDL_PIXELFORMAT_ARGB8888:
gabomdq@6320
  1390
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_RGB;
gabomdq@6320
  1391
                        break;
gabomdq@6320
  1392
                    case SDL_PIXELFORMAT_RGB888:
gabomdq@6320
  1393
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
gabomdq@6320
  1394
                        break;
gabomdq@6320
  1395
                }
gabomdq@6320
  1396
                break;
gabomdq@6320
  1397
            case SDL_PIXELFORMAT_RGB888:
gabomdq@6320
  1398
                switch (renderer->target->format)
gabomdq@6320
  1399
                {
gabomdq@6320
  1400
                    case SDL_PIXELFORMAT_ABGR8888:
gabomdq@6320
  1401
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
gabomdq@6320
  1402
                        break;
gabomdq@6320
  1403
                    case SDL_PIXELFORMAT_ARGB8888:
gabomdq@6320
  1404
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
gabomdq@6320
  1405
                        break;
gabomdq@6320
  1406
                    case SDL_PIXELFORMAT_BGR888:
gabomdq@6320
  1407
                        sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
gabomdq@6320
  1408
                        break;
gabomdq@6320
  1409
                }
gabomdq@6320
  1410
                break;
gabomdq@6320
  1411
            }
gabomdq@6320
  1412
        }
slouken@7191
  1413
        else sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;   /* Texture formats match, use the non color mapping shader (even if the formats are not ABGR) */
gabomdq@6320
  1414
    }
gabomdq@6320
  1415
    else {
gabomdq@6320
  1416
        switch (texture->format)
gabomdq@6320
  1417
        {
gabomdq@6320
  1418
            case SDL_PIXELFORMAT_ABGR8888:
gabomdq@6320
  1419
                sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
gabomdq@6320
  1420
                break;
gabomdq@6320
  1421
            case SDL_PIXELFORMAT_ARGB8888:
gabomdq@6320
  1422
                sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
gabomdq@6320
  1423
                break;
gabomdq@6320
  1424
            case SDL_PIXELFORMAT_BGR888:
gabomdq@6320
  1425
                sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
gabomdq@6320
  1426
                break;
gabomdq@6320
  1427
            case SDL_PIXELFORMAT_RGB888:
gabomdq@6320
  1428
                sourceType = GLES2_IMAGESOURCE_TEXTURE_RGB;
gabomdq@6320
  1429
                break;
slouken@6928
  1430
            default:
slouken@6928
  1431
                return -1;
gabomdq@6320
  1432
        }
gabomdq@6320
  1433
    }
gabomdq@6320
  1434
    if (GLES2_SelectProgram(renderer, sourceType, blendMode) < 0)
gabomdq@6320
  1435
        return -1;
gabomdq@6320
  1436
gabomdq@6320
  1437
    /* Select the target texture */
gabomdq@6320
  1438
    locTexture = rdata->current_program->uniform_locations[GLES2_UNIFORM_TEXTURE];
gabomdq@6320
  1439
    rdata->glGetError();
slouken@6188
  1440
    rdata->glActiveTexture(GL_TEXTURE0);
slouken@6188
  1441
    rdata->glBindTexture(tdata->texture_type, tdata->texture);
slouken@6188
  1442
    rdata->glUniform1i(locTexture, 0);
slouken@5201
  1443
slouken@5201
  1444
    /* Configure color modulation */
slouken@5201
  1445
    locModulation = rdata->current_program->uniform_locations[GLES2_UNIFORM_MODULATION];
slouken@6341
  1446
    if (renderer->target &&
slouken@6341
  1447
        (renderer->target->format == SDL_PIXELFORMAT_ARGB8888 ||
slouken@6341
  1448
         renderer->target->format == SDL_PIXELFORMAT_RGB888)) {
slouken@6341
  1449
        rdata->glUniform4f(locModulation,
slouken@6341
  1450
                    texture->b * inv255f,
slouken@6341
  1451
                    texture->g * inv255f,
slouken@6341
  1452
                    texture->r * inv255f,
slouken@6341
  1453
                    texture->a * inv255f);
slouken@6341
  1454
    } else {
slouken@6341
  1455
        rdata->glUniform4f(locModulation,
slouken@6341
  1456
                    texture->r * inv255f,
slouken@6341
  1457
                    texture->g * inv255f,
slouken@6341
  1458
                    texture->b * inv255f,
slouken@6341
  1459
                    texture->a * inv255f);
slouken@6341
  1460
    }
slouken@5355
  1461
slouken@5355
  1462
    /* Configure texture blending */
slouken@5355
  1463
    GLES2_SetBlendMode(rdata, blendMode);
slouken@5355
  1464
slouken@5355
  1465
    GLES2_SetTexCoords(rdata, SDL_TRUE);
slouken@5201
  1466
slouken@5201
  1467
    /* Emit the textured quad */
slouken@6528
  1468
    vertices[0] = dstrect->x;
slouken@6528
  1469
    vertices[1] = dstrect->y;
slouken@6528
  1470
    vertices[2] = (dstrect->x + dstrect->w);
slouken@6528
  1471
    vertices[3] = dstrect->y;
slouken@6528
  1472
    vertices[4] = dstrect->x;
slouken@6528
  1473
    vertices[5] = (dstrect->y + dstrect->h);
slouken@6528
  1474
    vertices[6] = (dstrect->x + dstrect->w);
slouken@6528
  1475
    vertices[7] = (dstrect->y + dstrect->h);
gabomdq@6320
  1476
    if (flip & SDL_FLIP_HORIZONTAL) {
gabomdq@6320
  1477
        tmp = vertices[0];
gabomdq@6320
  1478
        vertices[0] = vertices[4] = vertices[2];
gabomdq@6320
  1479
        vertices[2] = vertices[6] = tmp;
gabomdq@6320
  1480
    }
gabomdq@6320
  1481
    if (flip & SDL_FLIP_VERTICAL) {
gabomdq@6320
  1482
        tmp = vertices[1];
gabomdq@6320
  1483
        vertices[1] = vertices[3] = vertices[5];
gabomdq@6320
  1484
        vertices[5] = vertices[7] = tmp;
gabomdq@6320
  1485
    }
slouken@7191
  1486
gabomdq@6320
  1487
    rdata->glVertexAttribPointer(GLES2_ATTRIBUTE_ANGLE, 1, GL_FLOAT, GL_FALSE, 0, &fAngle);
gabomdq@6320
  1488
    rdata->glVertexAttribPointer(GLES2_ATTRIBUTE_CENTER, 2, GL_FLOAT, GL_FALSE, 0, translate);
slouken@6188
  1489
    rdata->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
slouken@6232
  1490
slouken@5201
  1491
    texCoords[0] = srcrect->x / (GLfloat)texture->w;
slouken@5201
  1492
    texCoords[1] = srcrect->y / (GLfloat)texture->h;
slouken@5201
  1493
    texCoords[2] = (srcrect->x + srcrect->w) / (GLfloat)texture->w;
slouken@5201
  1494
    texCoords[3] = srcrect->y / (GLfloat)texture->h;
slouken@5201
  1495
    texCoords[4] = srcrect->x / (GLfloat)texture->w;
slouken@5201
  1496
    texCoords[5] = (srcrect->y + srcrect->h) / (GLfloat)texture->h;
slouken@5201
  1497
    texCoords[6] = (srcrect->x + srcrect->w) / (GLfloat)texture->w;
slouken@5201
  1498
    texCoords[7] = (srcrect->y + srcrect->h) / (GLfloat)texture->h;
slouken@6188
  1499
    rdata->glVertexAttribPointer(GLES2_ATTRIBUTE_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 0, texCoords);
slouken@6188
  1500
    rdata->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
gabomdq@6320
  1501
    rdata->glDisableVertexAttribArray(GLES2_ATTRIBUTE_CENTER);
gabomdq@6320
  1502
    rdata->glDisableVertexAttribArray(GLES2_ATTRIBUTE_ANGLE);
icculus@7037
  1503
    if (rdata->glGetError() != GL_NO_ERROR) {
icculus@7037
  1504
        return SDL_SetError("Failed to render texture");
slouken@5201
  1505
    }
slouken@5201
  1506
    return 0;
slouken@5201
  1507
}
slouken@5201
  1508
slouken@6042
  1509
static int
slouken@6042
  1510
GLES2_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
slouken@6042
  1511
                    Uint32 pixel_format, void * pixels, int pitch)
slouken@6042
  1512
{
slouken@6188
  1513
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@6042
  1514
    Uint32 temp_format = SDL_PIXELFORMAT_ABGR8888;
slouken@6042
  1515
    void *temp_pixels;
slouken@6042
  1516
    int temp_pitch;
slouken@6042
  1517
    Uint8 *src, *dst, *tmp;
slouken@6042
  1518
    int w, h, length, rows;
slouken@6042
  1519
    int status;
slouken@6042
  1520
slouken@6042
  1521
    GLES2_ActivateRenderer(renderer);
slouken@6042
  1522
slouken@6042
  1523
    temp_pitch = rect->w * SDL_BYTESPERPIXEL(temp_format);
slouken@6042
  1524
    temp_pixels = SDL_malloc(rect->h * temp_pitch);
slouken@6042
  1525
    if (!temp_pixels) {
icculus@7037
  1526
        return SDL_OutOfMemory();
slouken@6042
  1527
    }
slouken@6042
  1528
slouken@7420
  1529
    SDL_GetRendererOutputSize(renderer, &w, &h);
slouken@6042
  1530
slouken@6188
  1531
    rdata->glPixelStorei(GL_PACK_ALIGNMENT, 1);
slouken@6042
  1532
slouken@6188
  1533
    rdata->glReadPixels(rect->x, (h-rect->y)-rect->h, rect->w, rect->h,
slouken@6042
  1534
                       GL_RGBA, GL_UNSIGNED_BYTE, temp_pixels);
slouken@6042
  1535
slouken@6042
  1536
    /* Flip the rows to be top-down */
slouken@6042
  1537
    length = rect->w * SDL_BYTESPERPIXEL(temp_format);
slouken@6042
  1538
    src = (Uint8*)temp_pixels + (rect->h-1)*temp_pitch;
slouken@6042
  1539
    dst = (Uint8*)temp_pixels;
slouken@6042
  1540
    tmp = SDL_stack_alloc(Uint8, length);
slouken@6042
  1541
    rows = rect->h / 2;
slouken@6042
  1542
    while (rows--) {
slouken@6042
  1543
        SDL_memcpy(tmp, dst, length);
slouken@6042
  1544
        SDL_memcpy(dst, src, length);
slouken@6042
  1545
        SDL_memcpy(src, tmp, length);
slouken@6042
  1546
        dst += temp_pitch;
slouken@6042
  1547
        src -= temp_pitch;
slouken@6042
  1548
    }
slouken@6042
  1549
    SDL_stack_free(tmp);
slouken@6042
  1550
slouken@6042
  1551
    status = SDL_ConvertPixels(rect->w, rect->h,
slouken@6042
  1552
                               temp_format, temp_pixels, temp_pitch,
slouken@6042
  1553
                               pixel_format, pixels, pitch);
slouken@6042
  1554
    SDL_free(temp_pixels);
slouken@6042
  1555
slouken@6042
  1556
    return status;
slouken@6042
  1557
}
slouken@6042
  1558
slouken@5201
  1559
static void
slouken@5201
  1560
GLES2_RenderPresent(SDL_Renderer *renderer)
slouken@5201
  1561
{
slouken@5201
  1562
    GLES2_ActivateRenderer(renderer);
slouken@5201
  1563
slouken@5201
  1564
    /* Tell the video driver to swap buffers */
slouken@5201
  1565
    SDL_GL_SwapWindow(renderer->window);
slouken@5201
  1566
}
slouken@5201
  1567
gabomdq@6414
  1568
gabomdq@6414
  1569
/*************************************************************************************************
gabomdq@6414
  1570
 * Bind/unbinding of textures
gabomdq@6414
  1571
 *************************************************************************************************/
gabomdq@6414
  1572
static int GLES2_BindTexture (SDL_Renderer * renderer, SDL_Texture *texture, float *texw, float *texh);
gabomdq@6414
  1573
static int GLES2_UnbindTexture (SDL_Renderer * renderer, SDL_Texture *texture);
gabomdq@6414
  1574
gabomdq@6414
  1575
static int GLES2_BindTexture (SDL_Renderer * renderer, SDL_Texture *texture, float *texw, float *texh) {
gabomdq@6414
  1576
    GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
gabomdq@6414
  1577
    GLES2_TextureData *texturedata = (GLES2_TextureData *)texture->driverdata;
gabomdq@6414
  1578
    GLES2_ActivateRenderer(renderer);
gabomdq@6414
  1579
gabomdq@6414
  1580
    data->glBindTexture(texturedata->texture_type, texturedata->texture);
gabomdq@6414
  1581
gabomdq@6414
  1582
    if(texw) *texw = 1.0;
gabomdq@6414
  1583
    if(texh) *texh = 1.0;
gabomdq@6414
  1584
gabomdq@6414
  1585
    return 0;
gabomdq@6414
  1586
}
gabomdq@6414
  1587
gabomdq@6414
  1588
static int GLES2_UnbindTexture (SDL_Renderer * renderer, SDL_Texture *texture) {
gabomdq@6414
  1589
    GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
gabomdq@6414
  1590
    GLES2_TextureData *texturedata = (GLES2_TextureData *)texture->driverdata;
gabomdq@6414
  1591
    GLES2_ActivateRenderer(renderer);
gabomdq@6414
  1592
icculus@7075
  1593
    data->glBindTexture(texturedata->texture_type, 0);
gabomdq@6414
  1594
gabomdq@6414
  1595
    return 0;
gabomdq@6414
  1596
}
gabomdq@6414
  1597
gabomdq@6414
  1598
slouken@5201
  1599
/*************************************************************************************************
slouken@5201
  1600
 * Renderer instantiation                                                                        *
slouken@5201
  1601
 *************************************************************************************************/
slouken@5201
  1602
slouken@5201
  1603
#define GL_NVIDIA_PLATFORM_BINARY_NV 0x890B
slouken@5201
  1604
slouken@5355
  1605
static void
slouken@5355
  1606
GLES2_ResetState(SDL_Renderer *renderer)
slouken@5355
  1607
{
slouken@5355
  1608
    GLES2_DriverContext *rdata = (GLES2_DriverContext *) renderer->driverdata;
slouken@5355
  1609
slouken@5355
  1610
    if (SDL_CurrentContext == rdata->context) {
slouken@5355
  1611
        GLES2_UpdateViewport(renderer);
slouken@5355
  1612
    } else {
slouken@5355
  1613
        GLES2_ActivateRenderer(renderer);
slouken@5355
  1614
    }
slouken@5355
  1615
slouken@5355
  1616
    rdata->current.blendMode = -1;
slouken@5355
  1617
    rdata->current.tex_coords = SDL_FALSE;
slouken@5355
  1618
slouken@6188
  1619
    rdata->glEnableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
slouken@6188
  1620
    rdata->glDisableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
slouken@5355
  1621
}
slouken@5355
  1622
slouken@5201
  1623
static SDL_Renderer *
slouken@5201
  1624
GLES2_CreateRenderer(SDL_Window *window, Uint32 flags)
slouken@5201
  1625
{
slouken@5201
  1626
    SDL_Renderer *renderer;
slouken@5201
  1627
    GLES2_DriverContext *rdata;
slouken@5201
  1628
    GLint nFormats;
slouken@5201
  1629
#ifndef ZUNE_HD
slouken@5201
  1630
    GLboolean hasCompiler;
slouken@5201
  1631
#endif
slouken@6188
  1632
    Uint32 windowFlags;
slouken@6271
  1633
    GLint window_framebuffer;
slouken@6232
  1634
slouken@6371
  1635
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_EGL, 1);
slouken@6188
  1636
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
slouken@6188
  1637
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
slouken@6232
  1638
slouken@6188
  1639
    windowFlags = SDL_GetWindowFlags(window);
slouken@6188
  1640
    if (!(windowFlags & SDL_WINDOW_OPENGL)) {
slouken@6188
  1641
        if (SDL_RecreateWindow(window, windowFlags | SDL_WINDOW_OPENGL) < 0) {
slouken@6188
  1642
            /* Uh oh, better try to put it back... */
slouken@6188
  1643
            SDL_RecreateWindow(window, windowFlags);
slouken@6188
  1644
            return NULL;
slouken@6188
  1645
        }
slouken@6188
  1646
    }
slouken@5201
  1647
slouken@5201
  1648
    /* Create the renderer struct */
slouken@5201
  1649
    renderer = (SDL_Renderer *)SDL_calloc(1, sizeof(SDL_Renderer));
slouken@5209
  1650
    if (!renderer) {
slouken@5209
  1651
        SDL_OutOfMemory();
slouken@5209
  1652
        return NULL;
slouken@5209
  1653
    }
slouken@5209
  1654
slouken@5201
  1655
    rdata = (GLES2_DriverContext *)SDL_calloc(1, sizeof(GLES2_DriverContext));
slouken@5209
  1656
    if (!rdata) {
slouken@5209
  1657
        GLES2_DestroyRenderer(renderer);
slouken@5201
  1658
        SDL_OutOfMemory();
slouken@5201
  1659
        return NULL;
slouken@5201
  1660
    }
slouken@5201
  1661
    renderer->info = GLES2_RenderDriver.info;
slouken@6237
  1662
    renderer->info.flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE;
slouken@5201
  1663
    renderer->driverdata = rdata;
slouken@6171
  1664
    renderer->window = window;
slouken@5201
  1665
slouken@5209
  1666
    /* Create an OpenGL ES 2.0 context */
slouken@5201
  1667
    rdata->context = SDL_GL_CreateContext(window);
slouken@5201
  1668
    if (!rdata->context)
slouken@5201
  1669
    {
slouken@5209
  1670
        GLES2_DestroyRenderer(renderer);
slouken@5201
  1671
        return NULL;
slouken@5201
  1672
    }
slouken@5202
  1673
    if (SDL_GL_MakeCurrent(window, rdata->context) < 0) {
slouken@5209
  1674
        GLES2_DestroyRenderer(renderer);
slouken@5202
  1675
        return NULL;
slouken@5202
  1676
    }
slouken@5202
  1677
slouken@6188
  1678
    if (GLES2_LoadFunctions(rdata) < 0) {
slouken@6188
  1679
        GLES2_DestroyRenderer(renderer);
slouken@6188
  1680
        return NULL;
slouken@6188
  1681
    }
slouken@6188
  1682
slouken@5202
  1683
    if (flags & SDL_RENDERER_PRESENTVSYNC) {
slouken@5202
  1684
        SDL_GL_SetSwapInterval(1);
slouken@5202
  1685
    } else {
slouken@5202
  1686
        SDL_GL_SetSwapInterval(0);
slouken@5202
  1687
    }
slouken@5202
  1688
    if (SDL_GL_GetSwapInterval() > 0) {
slouken@5202
  1689
        renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
slouken@5202
  1690
    }
slouken@5201
  1691
slouken@5201
  1692
    /* Determine supported shader formats */
slouken@5201
  1693
    /* HACK: glGetInteger is broken on the Zune HD's compositor, so we just hardcode this */
slouken@6188
  1694
    rdata->glGetError();
slouken@5201
  1695
#ifdef ZUNE_HD
slouken@5201
  1696
    nFormats = 1;
slouken@5201
  1697
#else /* !ZUNE_HD */
slouken@6188
  1698
    rdata->glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &nFormats);
slouken@6188
  1699
    rdata->glGetBooleanv(GL_SHADER_COMPILER, &hasCompiler);
slouken@5201
  1700
    if (hasCompiler)
slouken@5201
  1701
        ++nFormats;
slouken@5201
  1702
#endif /* ZUNE_HD */
slouken@5201
  1703
    rdata->shader_formats = (GLenum *)SDL_calloc(nFormats, sizeof(GLenum));
slouken@5201
  1704
    if (!rdata->shader_formats)
slouken@5201
  1705
    {
slouken@5209
  1706
        GLES2_DestroyRenderer(renderer);
slouken@5201
  1707
        SDL_OutOfMemory();
slouken@5201
  1708
        return NULL;
slouken@5201
  1709
    }
slouken@5201
  1710
    rdata->shader_format_count = nFormats;
slouken@5201
  1711
#ifdef ZUNE_HD
slouken@5201
  1712
    rdata->shader_formats[0] = GL_NVIDIA_PLATFORM_BINARY_NV;
slouken@5201
  1713
#else /* !ZUNE_HD */
slouken@6188
  1714
    rdata->glGetIntegerv(GL_SHADER_BINARY_FORMATS, (GLint *)rdata->shader_formats);
slouken@6188
  1715
    if (rdata->glGetError() != GL_NO_ERROR)
slouken@5201
  1716
    {
slouken@5209
  1717
        GLES2_DestroyRenderer(renderer);
slouken@5201
  1718
        SDL_SetError("Failed to query supported shader formats");
slouken@5201
  1719
        return NULL;
slouken@5201
  1720
    }
slouken@5201
  1721
    if (hasCompiler)
slouken@5201
  1722
        rdata->shader_formats[nFormats - 1] = (GLenum)-1;
slouken@5201
  1723
#endif /* ZUNE_HD */
slouken@5201
  1724
slouken@6232
  1725
    rdata->framebuffers = NULL;
slouken@6271
  1726
    rdata->glGetIntegerv(GL_FRAMEBUFFER_BINDING, &window_framebuffer);
slouken@6271
  1727
    rdata->window_framebuffer = (GLuint)window_framebuffer;
slouken@6232
  1728
slouken@5201
  1729
    /* Populate the function pointers for the module */
slouken@5201
  1730
    renderer->WindowEvent         = &GLES2_WindowEvent;
slouken@5201
  1731
    renderer->CreateTexture       = &GLES2_CreateTexture;
slouken@5201
  1732
    renderer->UpdateTexture       = &GLES2_UpdateTexture;
slouken@5201
  1733
    renderer->LockTexture         = &GLES2_LockTexture;
slouken@5201
  1734
    renderer->UnlockTexture       = &GLES2_UnlockTexture;
slouken@6247
  1735
    renderer->SetRenderTarget     = &GLES2_SetRenderTarget;
slouken@5297
  1736
    renderer->UpdateViewport      = &GLES2_UpdateViewport;
slouken@7141
  1737
    renderer->UpdateClipRect      = &GLES2_UpdateClipRect;
slouken@5201
  1738
    renderer->RenderClear         = &GLES2_RenderClear;
slouken@5201
  1739
    renderer->RenderDrawPoints    = &GLES2_RenderDrawPoints;
slouken@5201
  1740
    renderer->RenderDrawLines     = &GLES2_RenderDrawLines;
slouken@5201
  1741
    renderer->RenderFillRects     = &GLES2_RenderFillRects;
slouken@5201
  1742
    renderer->RenderCopy          = &GLES2_RenderCopy;
slouken@7141
  1743
    renderer->RenderCopyEx        = &GLES2_RenderCopyEx;
slouken@6042
  1744
    renderer->RenderReadPixels    = &GLES2_RenderReadPixels;
slouken@5201
  1745
    renderer->RenderPresent       = &GLES2_RenderPresent;
slouken@5201
  1746
    renderer->DestroyTexture      = &GLES2_DestroyTexture;
slouken@5201
  1747
    renderer->DestroyRenderer     = &GLES2_DestroyRenderer;
gabomdq@6414
  1748
    renderer->GL_BindTexture      = &GLES2_BindTexture;
gabomdq@6414
  1749
    renderer->GL_UnbindTexture    = &GLES2_UnbindTexture;
slouken@5355
  1750
slouken@5355
  1751
    GLES2_ResetState(renderer);
slouken@5355
  1752
slouken@5201
  1753
    return renderer;
slouken@5201
  1754
}
slouken@5201
  1755
slouken@5226
  1756
#endif /* SDL_VIDEO_RENDER_OGL_ES2 && !SDL_RENDER_DISABLED */
slouken@5201
  1757
slouken@5201
  1758
/* vi: set ts=4 sw=4 expandtab: */