src/render/opengles2/SDL_render_gles2.c
author Sam Lantinga <slouken@libsdl.org>
Sun, 06 Feb 2011 00:48:16 -0800
changeset 5202 1f2b17f42fd0
parent 5201 523409574510
child 5204 daa5463466c5
permissions -rw-r--r--
Removed extra unneeded pixel formats, added support for VSYNC on other platforms besides Zune HD.
slouken@5201
     1
/*
slouken@5201
     2
    SDL - Simple DirectMedia Layer
slouken@5201
     3
    Copyright (C) 2010 itsnotabigtruck.
slouken@5201
     4
slouken@5201
     5
    Permission is hereby granted, free of charge, to any person obtaining a
slouken@5201
     6
    copy of this software and associated documentation files (the "Software"),
slouken@5201
     7
    to deal in the Software without restriction, including without limitation
slouken@5201
     8
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
slouken@5201
     9
    and/or sell copies of the Software, and to permit persons to whom the
slouken@5201
    10
    Software is furnished to do so, subject to the following conditions:
slouken@5201
    11
slouken@5201
    12
    The above copyright notice and this permission notice shall be included in
slouken@5201
    13
    all copies or substantial portions of the Software.
slouken@5201
    14
slouken@5201
    15
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
slouken@5201
    16
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
slouken@5201
    17
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
slouken@5201
    18
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
slouken@5201
    19
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
slouken@5201
    20
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
slouken@5201
    21
    DEALINGS IN THE SOFTWARE.
slouken@5201
    22
*/
slouken@5201
    23
slouken@5201
    24
#include "SDL_config.h"
slouken@5201
    25
slouken@5201
    26
#if SDL_VIDEO_RENDER_OGL_ES2
slouken@5201
    27
slouken@5201
    28
#ifdef __IPHONEOS__
slouken@5201
    29
#include <OpenGLES/ES2/gl.h>
slouken@5201
    30
#include <OpenGLES/ES2/glext.h>
slouken@5201
    31
#else
slouken@5201
    32
#include <GLES2/gl2.h>
slouken@5201
    33
#include <GLES2/gl2ext.h>
slouken@5201
    34
#endif
slouken@5201
    35
#include "../SDL_sysrender.h"
slouken@5201
    36
#include "SDL_shaders_gles2.h"
slouken@5201
    37
slouken@5201
    38
/*************************************************************************************************
slouken@5201
    39
 * Bootstrap data                                                                                *
slouken@5201
    40
 *************************************************************************************************/
slouken@5201
    41
slouken@5201
    42
static SDL_Renderer *GLES2_CreateRenderer(SDL_Window *window, Uint32 flags);
slouken@5201
    43
slouken@5201
    44
SDL_RenderDriver GLES2_RenderDriver = {
slouken@5201
    45
    GLES2_CreateRenderer,
slouken@5201
    46
    {
slouken@5201
    47
        "opengles2",
slouken@5201
    48
        (SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC),
slouken@5202
    49
        1,
slouken@5202
    50
        {SDL_PIXELFORMAT_ABGR8888},
slouken@5201
    51
        0,
slouken@5201
    52
        0
slouken@5201
    53
    }
slouken@5201
    54
};
slouken@5201
    55
slouken@5201
    56
/*************************************************************************************************
slouken@5201
    57
 * Context structures                                                                            *
slouken@5201
    58
 *************************************************************************************************/
slouken@5201
    59
slouken@5201
    60
typedef struct GLES2_TextureData
slouken@5201
    61
{
slouken@5201
    62
    GLenum texture;
slouken@5201
    63
    GLenum texture_type;
slouken@5201
    64
    GLenum pixel_format;
slouken@5201
    65
    GLenum pixel_type;
slouken@5201
    66
    void *pixel_data;
slouken@5201
    67
    size_t pitch;
slouken@5201
    68
} GLES2_TextureData;
slouken@5201
    69
slouken@5201
    70
typedef struct GLES2_ShaderCacheEntry
slouken@5201
    71
{
slouken@5201
    72
    GLuint id;
slouken@5201
    73
    GLES2_ShaderType type;
slouken@5201
    74
    const GLES2_ShaderInstance *instance;
slouken@5201
    75
    int references;
slouken@5201
    76
    struct GLES2_ShaderCacheEntry *prev;
slouken@5201
    77
    struct GLES2_ShaderCacheEntry *next;
slouken@5201
    78
} GLES2_ShaderCacheEntry;
slouken@5201
    79
slouken@5201
    80
typedef struct GLES2_ShaderCache
slouken@5201
    81
{
slouken@5201
    82
    int count;
slouken@5201
    83
    GLES2_ShaderCacheEntry *head;
slouken@5201
    84
} GLES2_ShaderCache;
slouken@5201
    85
slouken@5201
    86
typedef struct GLES2_ProgramCacheEntry
slouken@5201
    87
{
slouken@5201
    88
    GLuint id;
slouken@5201
    89
    SDL_BlendMode blend_mode;
slouken@5201
    90
    GLES2_ShaderCacheEntry *vertex_shader;
slouken@5201
    91
    GLES2_ShaderCacheEntry *fragment_shader;
slouken@5201
    92
    GLuint uniform_locations[16];
slouken@5201
    93
    struct GLES2_ProgramCacheEntry *prev;
slouken@5201
    94
    struct GLES2_ProgramCacheEntry *next;
slouken@5201
    95
} GLES2_ProgramCacheEntry;
slouken@5201
    96
slouken@5201
    97
typedef struct GLES2_ProgramCache
slouken@5201
    98
{
slouken@5201
    99
    int count;
slouken@5201
   100
    GLES2_ProgramCacheEntry *head;
slouken@5201
   101
    GLES2_ProgramCacheEntry *tail;
slouken@5201
   102
} GLES2_ProgramCache;
slouken@5201
   103
slouken@5201
   104
typedef enum
slouken@5201
   105
{
slouken@5201
   106
    GLES2_ATTRIBUTE_POSITION = 0,
slouken@5201
   107
    GLES2_ATTRIBUTE_TEXCOORD = 1
slouken@5201
   108
} GLES2_Attribute;
slouken@5201
   109
slouken@5201
   110
typedef enum
slouken@5201
   111
{
slouken@5201
   112
    GLES2_UNIFORM_PROJECTION,
slouken@5201
   113
    GLES2_UNIFORM_TEXTURE,
slouken@5201
   114
    GLES2_UNIFORM_MODULATION,
slouken@5201
   115
    GLES2_UNIFORM_COLOR,
slouken@5201
   116
    GLES2_UNIFORM_COLORTABLE
slouken@5201
   117
} GLES2_Uniform;
slouken@5201
   118
slouken@5201
   119
typedef enum
slouken@5201
   120
{
slouken@5201
   121
    GLES2_IMAGESOURCE_SOLID,
slouken@5201
   122
    GLES2_IMAGESOURCE_TEXTURE
slouken@5201
   123
} GLES2_ImageSource;
slouken@5201
   124
slouken@5201
   125
typedef struct GLES2_DriverContext
slouken@5201
   126
{
slouken@5201
   127
    SDL_GLContext *context;
slouken@5201
   128
    int shader_format_count;
slouken@5201
   129
    GLenum *shader_formats;
slouken@5201
   130
    GLES2_ShaderCache shader_cache;
slouken@5201
   131
    GLES2_ProgramCache program_cache;
slouken@5201
   132
    GLES2_ProgramCacheEntry *current_program;
slouken@5201
   133
	SDL_bool updateSize;
slouken@5201
   134
} GLES2_DriverContext;
slouken@5201
   135
slouken@5201
   136
#define GLES2_MAX_CACHED_PROGRAMS 8
slouken@5201
   137
slouken@5201
   138
/*************************************************************************************************
slouken@5201
   139
 * Renderer state APIs                                                                           *
slouken@5201
   140
 *************************************************************************************************/
slouken@5201
   141
slouken@5201
   142
static void GLES2_WindowEvent(SDL_Renderer * renderer,
slouken@5201
   143
                              const SDL_WindowEvent *event);
slouken@5201
   144
static int GLES2_ActivateRenderer(SDL_Renderer *renderer);
slouken@5201
   145
static int GLES2_DisplayModeChanged(SDL_Renderer *renderer);
slouken@5201
   146
static void GLES2_DestroyRenderer(SDL_Renderer *renderer);
slouken@5201
   147
slouken@5201
   148
static SDL_GLContext SDL_CurrentContext = NULL;
slouken@5201
   149
slouken@5201
   150
static int
slouken@5201
   151
GLES2_ActivateRenderer(SDL_Renderer * renderer)
slouken@5201
   152
{
slouken@5201
   153
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   154
    SDL_Window *window = renderer->window;
slouken@5201
   155
slouken@5201
   156
    if (SDL_CurrentContext != rdata->context) {
slouken@5201
   157
        /* Null out the current program to ensure we set it again */
slouken@5201
   158
        rdata->current_program = NULL;
slouken@5201
   159
slouken@5201
   160
        if (SDL_GL_MakeCurrent(window, rdata->context) < 0) {
slouken@5201
   161
            return -1;
slouken@5201
   162
        }
slouken@5201
   163
        SDL_CurrentContext = rdata->context;
slouken@5201
   164
    }
slouken@5201
   165
    if (rdata->updateSize) {
slouken@5201
   166
        int w, h;
slouken@5201
   167
slouken@5201
   168
        SDL_GetWindowSize(window, &w, &h);
slouken@5201
   169
        glViewport(0, 0, w, h);
slouken@5201
   170
        rdata->updateSize = SDL_FALSE;
slouken@5201
   171
    }
slouken@5201
   172
    return 0;
slouken@5201
   173
}
slouken@5201
   174
slouken@5201
   175
static void
slouken@5201
   176
GLES2_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
slouken@5201
   177
{
slouken@5201
   178
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   179
slouken@5201
   180
    if (event->event == SDL_WINDOWEVENT_RESIZED) {
slouken@5201
   181
        /* Rebind the context to the window area */
slouken@5201
   182
        SDL_CurrentContext = NULL;
slouken@5201
   183
        rdata->updateSize = SDL_TRUE;
slouken@5201
   184
    }
slouken@5201
   185
}
slouken@5201
   186
slouken@5201
   187
static void
slouken@5201
   188
GLES2_DestroyRenderer(SDL_Renderer *renderer)
slouken@5201
   189
{
slouken@5201
   190
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   191
    GLES2_ProgramCacheEntry *entry;
slouken@5201
   192
    GLES2_ProgramCacheEntry *next;
slouken@5201
   193
slouken@5201
   194
    GLES2_ActivateRenderer(renderer);
slouken@5201
   195
slouken@5201
   196
    /* Deallocate everything */
slouken@5201
   197
    entry = rdata->program_cache.head;
slouken@5201
   198
    while (entry)
slouken@5201
   199
    {
slouken@5201
   200
        glDeleteShader(entry->vertex_shader->id);
slouken@5201
   201
        glDeleteShader(entry->fragment_shader->id);
slouken@5201
   202
        SDL_free(entry->vertex_shader);
slouken@5201
   203
        SDL_free(entry->fragment_shader);
slouken@5201
   204
        glDeleteProgram(entry->id);
slouken@5201
   205
        next = entry->next;
slouken@5201
   206
        SDL_free(entry);
slouken@5201
   207
        entry = next;
slouken@5201
   208
    }
slouken@5201
   209
    SDL_GL_DeleteContext(rdata->context);
slouken@5201
   210
    SDL_free(rdata->shader_formats);
slouken@5201
   211
    SDL_free(renderer->driverdata);
slouken@5201
   212
    SDL_free(renderer);
slouken@5201
   213
}
slouken@5201
   214
slouken@5201
   215
/*************************************************************************************************
slouken@5201
   216
 * Texture APIs                                                                                  *
slouken@5201
   217
 *************************************************************************************************/
slouken@5201
   218
slouken@5201
   219
static int GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture);
slouken@5201
   220
static void GLES2_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture);
slouken@5201
   221
static int GLES2_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,
slouken@5201
   222
                             void **pixels, int *pitch);
slouken@5201
   223
static void GLES2_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture);
slouken@5201
   224
static int GLES2_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,
slouken@5201
   225
                               const void *pixels, int pitch);
slouken@5201
   226
slouken@5201
   227
static int
slouken@5201
   228
GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
slouken@5201
   229
{
slouken@5201
   230
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   231
    GLES2_TextureData *tdata;
slouken@5201
   232
    GLenum format;
slouken@5201
   233
    GLenum type;
slouken@5201
   234
slouken@5201
   235
    GLES2_ActivateRenderer(renderer);
slouken@5201
   236
slouken@5201
   237
    /* Determine the corresponding GLES texture format params */
slouken@5201
   238
    switch (texture->format)
slouken@5201
   239
    {
slouken@5201
   240
    case SDL_PIXELFORMAT_ABGR8888:
slouken@5201
   241
        format = GL_RGBA;
slouken@5201
   242
        type = GL_UNSIGNED_BYTE;
slouken@5201
   243
        break;
slouken@5201
   244
    default:
slouken@5201
   245
        SDL_SetError("Texture format not supported");
slouken@5201
   246
        return -1;
slouken@5201
   247
    }
slouken@5201
   248
slouken@5201
   249
    /* Allocate a texture struct */
slouken@5201
   250
    tdata = (GLES2_TextureData *)SDL_calloc(1, sizeof(GLES2_TextureData));
slouken@5201
   251
    if (!tdata)
slouken@5201
   252
    {
slouken@5201
   253
        SDL_OutOfMemory();
slouken@5201
   254
        return -1;
slouken@5201
   255
    }
slouken@5201
   256
    tdata->texture = 0;
slouken@5201
   257
    tdata->texture_type = GL_TEXTURE_2D;
slouken@5201
   258
    tdata->pixel_format = format;
slouken@5201
   259
    tdata->pixel_type = type;
slouken@5201
   260
slouken@5201
   261
    /* Allocate a blob for image data */
slouken@5201
   262
    if (texture->access == SDL_TEXTUREACCESS_STREAMING)
slouken@5201
   263
    {
slouken@5201
   264
        tdata->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
slouken@5201
   265
        tdata->pixel_data = SDL_malloc(tdata->pitch * texture->h);
slouken@5201
   266
        if (!tdata->pixel_data)
slouken@5201
   267
        {
slouken@5201
   268
            SDL_OutOfMemory();
slouken@5201
   269
            SDL_free(tdata);
slouken@5201
   270
            return -1;
slouken@5201
   271
        }
slouken@5201
   272
    }
slouken@5201
   273
slouken@5201
   274
    /* Allocate the texture */
slouken@5201
   275
    glGetError();
slouken@5201
   276
    glGenTextures(1, &tdata->texture);
slouken@5201
   277
    glActiveTexture(GL_TEXTURE0);
slouken@5201
   278
    glBindTexture(tdata->texture_type, tdata->texture);
slouken@5201
   279
    glTexParameteri(tdata->texture_type, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
slouken@5201
   280
    glTexParameteri(tdata->texture_type, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
slouken@5201
   281
    glTexParameteri(tdata->texture_type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
slouken@5201
   282
    glTexParameteri(tdata->texture_type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
slouken@5201
   283
    glTexImage2D(tdata->texture_type, 0, format, texture->w, texture->h, 0, format, type, NULL);
slouken@5201
   284
    if (glGetError() != GL_NO_ERROR)
slouken@5201
   285
    {
slouken@5201
   286
        SDL_SetError("Texture creation failed");
slouken@5201
   287
        glDeleteTextures(1, &tdata->texture);
slouken@5201
   288
        SDL_free(tdata);
slouken@5201
   289
        return -1;
slouken@5201
   290
    }
slouken@5201
   291
    texture->driverdata = tdata;
slouken@5201
   292
    return 0;
slouken@5201
   293
}
slouken@5201
   294
slouken@5201
   295
static void
slouken@5201
   296
GLES2_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
slouken@5201
   297
{
slouken@5201
   298
    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
slouken@5201
   299
slouken@5201
   300
    GLES2_ActivateRenderer(renderer);
slouken@5201
   301
slouken@5201
   302
    /* Destroy the texture */
slouken@5201
   303
    if (tdata)
slouken@5201
   304
    {
slouken@5201
   305
        glDeleteTextures(1, &tdata->texture);
slouken@5201
   306
        SDL_free(tdata->pixel_data);
slouken@5201
   307
        SDL_free(tdata);
slouken@5201
   308
        texture->driverdata = NULL;
slouken@5201
   309
    }
slouken@5201
   310
}
slouken@5201
   311
slouken@5201
   312
static int
slouken@5201
   313
GLES2_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,
slouken@5201
   314
                  void **pixels, int *pitch)
slouken@5201
   315
{
slouken@5201
   316
    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
slouken@5201
   317
slouken@5201
   318
    /* Retrieve the buffer/pitch for the specified region */
slouken@5201
   319
    *pixels = (Uint8 *)tdata->pixel_data +
slouken@5201
   320
              (tdata->pitch * rect->y) +
slouken@5201
   321
              (rect->x * SDL_BYTESPERPIXEL(texture->format));
slouken@5201
   322
    *pitch = tdata->pitch;
slouken@5201
   323
slouken@5201
   324
    return 0;
slouken@5201
   325
}
slouken@5201
   326
slouken@5201
   327
static void
slouken@5201
   328
GLES2_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
slouken@5201
   329
{
slouken@5201
   330
    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
slouken@5201
   331
slouken@5201
   332
    GLES2_ActivateRenderer(renderer);
slouken@5201
   333
slouken@5201
   334
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
slouken@5201
   335
    glActiveTexture(GL_TEXTURE0);
slouken@5201
   336
    glBindTexture(tdata->texture_type, tdata->texture);
slouken@5201
   337
    glTexSubImage2D(tdata->texture_type, 0, 0, 0, texture->w, texture->h,
slouken@5201
   338
                    tdata->pixel_format, tdata->pixel_type, tdata->pixel_data);
slouken@5201
   339
}
slouken@5201
   340
slouken@5201
   341
static int
slouken@5201
   342
GLES2_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,
slouken@5201
   343
                    const void *pixels, int pitch)
slouken@5201
   344
{
slouken@5201
   345
    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
slouken@5201
   346
    Uint8 *blob = NULL;
slouken@5201
   347
    Uint8 *src;
slouken@5201
   348
    int srcPitch;
slouken@5201
   349
    Uint8 *dest;
slouken@5201
   350
    int y;
slouken@5201
   351
slouken@5201
   352
    GLES2_ActivateRenderer(renderer);
slouken@5201
   353
slouken@5201
   354
    /* Bail out if we're supposed to update an empty rectangle */
slouken@5201
   355
    if (rect->w <= 0 || rect->h <= 0)
slouken@5201
   356
        return 0;
slouken@5201
   357
slouken@5201
   358
    /* Reformat the texture data into a tightly packed array */
slouken@5201
   359
    srcPitch = rect->w * SDL_BYTESPERPIXEL(texture->format);
slouken@5201
   360
    src = (Uint8 *)pixels;
slouken@5201
   361
    if (pitch != srcPitch)
slouken@5201
   362
    {
slouken@5201
   363
        blob = (Uint8 *)SDL_malloc(srcPitch * rect->h);
slouken@5201
   364
        if (!blob)
slouken@5201
   365
        {
slouken@5201
   366
            SDL_OutOfMemory();
slouken@5201
   367
            return -1;
slouken@5201
   368
        }
slouken@5201
   369
        src = blob;
slouken@5201
   370
        for (y = 0; y < rect->h; ++y)
slouken@5201
   371
        {
slouken@5201
   372
            SDL_memcpy(src, pixels, srcPitch);
slouken@5201
   373
            src += srcPitch;
slouken@5201
   374
            pixels = (Uint8 *)pixels + pitch;
slouken@5201
   375
        }
slouken@5201
   376
        src = blob;
slouken@5201
   377
    }
slouken@5201
   378
slouken@5201
   379
    /* Create a texture subimage with the supplied data */
slouken@5201
   380
    glGetError();
slouken@5201
   381
    glActiveTexture(GL_TEXTURE0);
slouken@5201
   382
    glBindTexture(tdata->texture_type, tdata->texture);
slouken@5201
   383
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
slouken@5201
   384
    glTexSubImage2D(tdata->texture_type,
slouken@5201
   385
                    0,
slouken@5201
   386
                    rect->x,
slouken@5201
   387
                    rect->y,
slouken@5201
   388
                    rect->w,
slouken@5201
   389
                    rect->h,
slouken@5201
   390
                    tdata->pixel_format,
slouken@5201
   391
                    tdata->pixel_type,
slouken@5201
   392
                    src);
slouken@5201
   393
    if (glGetError() != GL_NO_ERROR)
slouken@5201
   394
    {
slouken@5201
   395
        SDL_SetError("Failed to update texture");
slouken@5201
   396
        return -1;
slouken@5201
   397
    }
slouken@5201
   398
slouken@5201
   399
    /* Update the (streaming) texture buffer, in one pass if possible */
slouken@5201
   400
    if (tdata->pixel_data)
slouken@5201
   401
    {
slouken@5201
   402
        dest = (Uint8 *)tdata->pixel_data +
slouken@5201
   403
               (tdata->pitch * rect->y) +
slouken@5201
   404
               (SDL_BYTESPERPIXEL(texture->format) * rect->x);
slouken@5201
   405
        if (rect->w == texture->w)
slouken@5201
   406
        {
slouken@5201
   407
            SDL_memcpy(dest, src, srcPitch * rect->h);
slouken@5201
   408
        }
slouken@5201
   409
        else
slouken@5201
   410
        {
slouken@5201
   411
            for (y = 0; y < rect->h; ++y)
slouken@5201
   412
            {
slouken@5201
   413
                SDL_memcpy(dest, src, srcPitch);
slouken@5201
   414
                src += srcPitch;
slouken@5201
   415
                dest += tdata->pitch;
slouken@5201
   416
            }
slouken@5201
   417
        }
slouken@5201
   418
    }
slouken@5201
   419
slouken@5201
   420
    /* Clean up and return */
slouken@5201
   421
    SDL_free(blob);
slouken@5201
   422
    return 0;
slouken@5201
   423
}
slouken@5201
   424
slouken@5201
   425
/*************************************************************************************************
slouken@5201
   426
 * Shader management functions                                                                   *
slouken@5201
   427
 *************************************************************************************************/
slouken@5201
   428
slouken@5201
   429
static GLES2_ShaderCacheEntry *GLES2_CacheShader(SDL_Renderer *renderer, GLES2_ShaderType type,
slouken@5201
   430
                                                 SDL_BlendMode blendMode);
slouken@5201
   431
static void GLES2_EvictShader(SDL_Renderer *renderer, GLES2_ShaderCacheEntry *entry);
slouken@5201
   432
static GLES2_ProgramCacheEntry *GLES2_CacheProgram(SDL_Renderer *renderer,
slouken@5201
   433
                                                   GLES2_ShaderCacheEntry *vertex,
slouken@5201
   434
                                                   GLES2_ShaderCacheEntry *fragment,
slouken@5201
   435
                                                   SDL_BlendMode blendMode);
slouken@5201
   436
static int GLES2_SelectProgram(SDL_Renderer *renderer, GLES2_ImageSource source,
slouken@5201
   437
                               SDL_BlendMode blendMode);
slouken@5201
   438
static int GLES2_SetOrthographicProjection(SDL_Renderer *renderer);
slouken@5201
   439
slouken@5201
   440
static GLES2_ProgramCacheEntry *
slouken@5201
   441
GLES2_CacheProgram(SDL_Renderer *renderer, GLES2_ShaderCacheEntry *vertex,
slouken@5201
   442
                   GLES2_ShaderCacheEntry *fragment, SDL_BlendMode blendMode)
slouken@5201
   443
{
slouken@5201
   444
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   445
    GLES2_ProgramCacheEntry *entry;
slouken@5201
   446
    GLES2_ShaderCacheEntry *shaderEntry;
slouken@5201
   447
    GLint linkSuccessful;
slouken@5201
   448
slouken@5201
   449
    /* Check if we've already cached this program */
slouken@5201
   450
    entry = rdata->program_cache.head;
slouken@5201
   451
    while (entry)
slouken@5201
   452
    {
slouken@5201
   453
        if (entry->vertex_shader == vertex && entry->fragment_shader == fragment)
slouken@5201
   454
            break;
slouken@5201
   455
        entry = entry->next;
slouken@5201
   456
    }
slouken@5201
   457
    if (entry)
slouken@5201
   458
    {
slouken@5201
   459
        if (rdata->program_cache.count > 1)
slouken@5201
   460
        {
slouken@5201
   461
            if (entry->next)
slouken@5201
   462
                entry->next->prev = entry->prev;
slouken@5201
   463
            if (entry->prev)
slouken@5201
   464
                entry->prev->next = entry->next;
slouken@5201
   465
            entry->prev = NULL;
slouken@5201
   466
            entry->next = rdata->program_cache.head;
slouken@5201
   467
            rdata->program_cache.head->prev = entry;
slouken@5201
   468
            rdata->program_cache.head = entry;
slouken@5201
   469
        }
slouken@5201
   470
        return entry;
slouken@5201
   471
    }
slouken@5201
   472
slouken@5201
   473
    /* Create a program cache entry */
slouken@5201
   474
    entry = (GLES2_ProgramCacheEntry *)SDL_calloc(1, sizeof(GLES2_ProgramCacheEntry));
slouken@5201
   475
    if (!entry)
slouken@5201
   476
    {
slouken@5201
   477
        SDL_OutOfMemory();
slouken@5201
   478
        return NULL;
slouken@5201
   479
    }
slouken@5201
   480
    entry->vertex_shader = vertex;
slouken@5201
   481
    entry->fragment_shader = fragment;
slouken@5201
   482
    entry->blend_mode = blendMode;
slouken@5201
   483
    
slouken@5201
   484
    /* Create the program and link it */
slouken@5201
   485
    glGetError();
slouken@5201
   486
    entry->id = glCreateProgram();
slouken@5201
   487
    glAttachShader(entry->id, vertex->id);
slouken@5201
   488
    glAttachShader(entry->id, fragment->id);
slouken@5201
   489
    glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_POSITION, "a_position");
slouken@5201
   490
    glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_TEXCOORD, "a_texCoord");
slouken@5201
   491
    glLinkProgram(entry->id);
slouken@5201
   492
    glGetProgramiv(entry->id, GL_LINK_STATUS, &linkSuccessful);
slouken@5201
   493
    if (glGetError() != GL_NO_ERROR || !linkSuccessful)
slouken@5201
   494
    {
slouken@5201
   495
        SDL_SetError("Failed to link shader program");
slouken@5201
   496
        glDeleteProgram(entry->id);
slouken@5201
   497
        SDL_free(entry);
slouken@5201
   498
        return NULL;
slouken@5201
   499
    }
slouken@5201
   500
    
slouken@5201
   501
    /* Predetermine locations of uniform variables */
slouken@5201
   502
    entry->uniform_locations[GLES2_UNIFORM_PROJECTION] =
slouken@5201
   503
        glGetUniformLocation(entry->id, "u_projection");
slouken@5201
   504
    entry->uniform_locations[GLES2_UNIFORM_TEXTURE] =
slouken@5201
   505
        glGetUniformLocation(entry->id, "u_texture");
slouken@5201
   506
    entry->uniform_locations[GLES2_UNIFORM_MODULATION] =
slouken@5201
   507
        glGetUniformLocation(entry->id, "u_modulation");
slouken@5201
   508
    entry->uniform_locations[GLES2_UNIFORM_COLOR] =
slouken@5201
   509
        glGetUniformLocation(entry->id, "u_color");
slouken@5201
   510
    entry->uniform_locations[GLES2_UNIFORM_COLORTABLE] =
slouken@5201
   511
        glGetUniformLocation(entry->id, "u_colorTable");
slouken@5201
   512
slouken@5201
   513
    /* Cache the linked program */
slouken@5201
   514
    if (rdata->program_cache.head)
slouken@5201
   515
    {
slouken@5201
   516
        entry->next = rdata->program_cache.head;
slouken@5201
   517
        rdata->program_cache.head->prev = entry;
slouken@5201
   518
    }
slouken@5201
   519
    else
slouken@5201
   520
    {
slouken@5201
   521
        rdata->program_cache.tail = entry;
slouken@5201
   522
    }
slouken@5201
   523
    rdata->program_cache.head = entry;
slouken@5201
   524
    ++rdata->program_cache.count;
slouken@5201
   525
slouken@5201
   526
    /* Increment the refcount of the shaders we're using */
slouken@5201
   527
    ++vertex->references;
slouken@5201
   528
    ++fragment->references;
slouken@5201
   529
slouken@5201
   530
    /* Evict the last entry from the cache if we exceed the limit */
slouken@5201
   531
    if (rdata->program_cache.count > GLES2_MAX_CACHED_PROGRAMS)
slouken@5201
   532
    {
slouken@5201
   533
        shaderEntry = rdata->program_cache.tail->vertex_shader;
slouken@5201
   534
        if (--shaderEntry->references <= 0)
slouken@5201
   535
            GLES2_EvictShader(renderer, shaderEntry);
slouken@5201
   536
        shaderEntry = rdata->program_cache.tail->fragment_shader;
slouken@5201
   537
        if (--shaderEntry->references <= 0)
slouken@5201
   538
            GLES2_EvictShader(renderer, shaderEntry);
slouken@5201
   539
        glDeleteProgram(rdata->program_cache.tail->id);
slouken@5201
   540
        rdata->program_cache.tail = rdata->program_cache.tail->prev;
slouken@5201
   541
        SDL_free(rdata->program_cache.tail->next);
slouken@5201
   542
        rdata->program_cache.tail->next = NULL;
slouken@5201
   543
        --rdata->program_cache.count;
slouken@5201
   544
    }
slouken@5201
   545
    return entry;
slouken@5201
   546
}
slouken@5201
   547
slouken@5201
   548
static GLES2_ShaderCacheEntry *
slouken@5201
   549
GLES2_CacheShader(SDL_Renderer *renderer, GLES2_ShaderType type, SDL_BlendMode blendMode)
slouken@5201
   550
{
slouken@5201
   551
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   552
    const GLES2_Shader *shader;
slouken@5201
   553
    const GLES2_ShaderInstance *instance = NULL;
slouken@5201
   554
    GLES2_ShaderCacheEntry *entry = NULL;
slouken@5201
   555
    GLint compileSuccessful = GL_FALSE;
slouken@5201
   556
    int i, j;
slouken@5201
   557
slouken@5201
   558
    /* Find the corresponding shader */
slouken@5201
   559
    shader = GLES2_GetShader(type, blendMode);
slouken@5201
   560
    if (!shader)
slouken@5201
   561
    {
slouken@5201
   562
        SDL_SetError("No shader matching the requested characteristics was found");
slouken@5201
   563
        return NULL;
slouken@5201
   564
    }
slouken@5201
   565
    
slouken@5201
   566
    /* Find a matching shader instance that's supported on this hardware */
slouken@5201
   567
    for (i = 0; i < shader->instance_count; ++i)
slouken@5201
   568
    {
slouken@5201
   569
        for (j = 0; j < rdata->shader_format_count; ++j)
slouken@5201
   570
        {
slouken@5201
   571
            if (!shader->instances)
slouken@5201
   572
                continue;
slouken@5201
   573
            if (shader->instances[i]->format != rdata->shader_formats[j])
slouken@5201
   574
                continue;
slouken@5201
   575
            instance = shader->instances[i];
slouken@5201
   576
            break;
slouken@5201
   577
        }
slouken@5201
   578
    }
slouken@5201
   579
    if (!instance)
slouken@5201
   580
    {
slouken@5201
   581
        SDL_SetError("The specified shader cannot be loaded on the current platform");
slouken@5201
   582
        return NULL;
slouken@5201
   583
    }
slouken@5201
   584
slouken@5201
   585
    /* Check if we've already cached this shader */
slouken@5201
   586
    entry = rdata->shader_cache.head;
slouken@5201
   587
    while (entry)
slouken@5201
   588
    {
slouken@5201
   589
        if (entry->instance == instance)
slouken@5201
   590
            break;
slouken@5201
   591
        entry = entry->next;
slouken@5201
   592
    }
slouken@5201
   593
    if (entry)
slouken@5201
   594
        return entry;
slouken@5201
   595
slouken@5201
   596
    /* Create a shader cache entry */
slouken@5201
   597
    entry = (GLES2_ShaderCacheEntry *)SDL_calloc(1, sizeof(GLES2_ShaderCacheEntry));
slouken@5201
   598
    if (!entry)
slouken@5201
   599
    {
slouken@5201
   600
        SDL_OutOfMemory();
slouken@5201
   601
        return NULL;
slouken@5201
   602
    }
slouken@5201
   603
    entry->type = type;
slouken@5201
   604
    entry->instance = instance;
slouken@5201
   605
slouken@5201
   606
    /* Compile or load the selected shader instance */
slouken@5201
   607
    glGetError();
slouken@5201
   608
    entry->id = glCreateShader(instance->type);
slouken@5201
   609
    if (instance->format == (GLenum)-1)
slouken@5201
   610
    {
slouken@5201
   611
        glShaderSource(entry->id, 1, (const char **)&instance->data, &instance->length);
slouken@5201
   612
        glCompileShader(entry->id);
slouken@5201
   613
        glGetShaderiv(entry->id, GL_COMPILE_STATUS, &compileSuccessful);
slouken@5201
   614
    }
slouken@5201
   615
    else
slouken@5201
   616
    {
slouken@5201
   617
        glShaderBinary(1, &entry->id, instance->format, instance->data, instance->length);
slouken@5201
   618
        compileSuccessful = GL_TRUE;
slouken@5201
   619
    }
slouken@5201
   620
    if (glGetError() != GL_NO_ERROR || !compileSuccessful)
slouken@5201
   621
    {
slouken@5201
   622
        SDL_SetError("Failed to load the specified shader");
slouken@5201
   623
        glDeleteShader(entry->id);
slouken@5201
   624
        SDL_free(entry);
slouken@5201
   625
        return NULL;
slouken@5201
   626
    }
slouken@5201
   627
slouken@5201
   628
    /* Link the shader entry in at the front of the cache */
slouken@5201
   629
    if (rdata->shader_cache.head)
slouken@5201
   630
    {
slouken@5201
   631
        entry->next = rdata->shader_cache.head;
slouken@5201
   632
        rdata->shader_cache.head->prev = entry;
slouken@5201
   633
    }
slouken@5201
   634
    rdata->shader_cache.head = entry;
slouken@5201
   635
    ++rdata->shader_cache.count;
slouken@5201
   636
    return entry;
slouken@5201
   637
}
slouken@5201
   638
slouken@5201
   639
static void
slouken@5201
   640
GLES2_EvictShader(SDL_Renderer *renderer, GLES2_ShaderCacheEntry *entry)
slouken@5201
   641
{
slouken@5201
   642
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   643
slouken@5201
   644
    /* Unlink the shader from the cache */
slouken@5201
   645
    if (entry->next)
slouken@5201
   646
        entry->next->prev = entry->prev;
slouken@5201
   647
    if (entry->prev)
slouken@5201
   648
        entry->prev->next = entry->next;
slouken@5201
   649
    if (rdata->shader_cache.head == entry)
slouken@5201
   650
        rdata->shader_cache.head = entry->next;
slouken@5201
   651
    --rdata->shader_cache.count;
slouken@5201
   652
slouken@5201
   653
    /* Deallocate the shader */
slouken@5201
   654
    glDeleteShader(entry->id);
slouken@5201
   655
    SDL_free(entry);
slouken@5201
   656
}
slouken@5201
   657
slouken@5201
   658
static int
slouken@5201
   659
GLES2_SelectProgram(SDL_Renderer *renderer, GLES2_ImageSource source, SDL_BlendMode blendMode)
slouken@5201
   660
{
slouken@5201
   661
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   662
    GLES2_ShaderCacheEntry *vertex = NULL;
slouken@5201
   663
    GLES2_ShaderCacheEntry *fragment = NULL;
slouken@5201
   664
    GLES2_ShaderType vtype, ftype;
slouken@5201
   665
    GLES2_ProgramCacheEntry *program;
slouken@5201
   666
slouken@5201
   667
    /* Select an appropriate shader pair for the specified modes */
slouken@5201
   668
    vtype = GLES2_SHADER_VERTEX_DEFAULT;
slouken@5201
   669
    switch (source)
slouken@5201
   670
    {
slouken@5201
   671
    case GLES2_IMAGESOURCE_SOLID:
slouken@5201
   672
        ftype = GLES2_SHADER_FRAGMENT_SOLID_SRC;
slouken@5201
   673
        break;
slouken@5201
   674
    case GLES2_IMAGESOURCE_TEXTURE:
slouken@5201
   675
        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_SRC;
slouken@5201
   676
        break;
slouken@5201
   677
    }
slouken@5201
   678
slouken@5201
   679
    /* Load the requested shaders */
slouken@5201
   680
    vertex = GLES2_CacheShader(renderer, vtype, blendMode);
slouken@5201
   681
    if (!vertex)
slouken@5201
   682
        goto fault;
slouken@5201
   683
    fragment = GLES2_CacheShader(renderer, ftype, blendMode);
slouken@5201
   684
    if (!fragment)
slouken@5201
   685
        goto fault;
slouken@5201
   686
slouken@5201
   687
    /* Check if we need to change programs at all */
slouken@5201
   688
    if (rdata->current_program &&
slouken@5201
   689
        rdata->current_program->vertex_shader == vertex &&
slouken@5201
   690
        rdata->current_program->fragment_shader == fragment)
slouken@5201
   691
        return 0;
slouken@5201
   692
slouken@5201
   693
    /* Generate a matching program */
slouken@5201
   694
    program = GLES2_CacheProgram(renderer, vertex, fragment, blendMode);
slouken@5201
   695
    if (!program)
slouken@5201
   696
        goto fault;
slouken@5201
   697
slouken@5201
   698
    /* Select that program in OpenGL */
slouken@5201
   699
    glGetError();
slouken@5201
   700
    glUseProgram(program->id);
slouken@5201
   701
    if (glGetError() != GL_NO_ERROR)
slouken@5201
   702
    {
slouken@5201
   703
        SDL_SetError("Failed to select program");
slouken@5201
   704
        goto fault;
slouken@5201
   705
    }
slouken@5201
   706
slouken@5201
   707
    /* Set the current program */
slouken@5201
   708
    rdata->current_program = program;
slouken@5201
   709
slouken@5201
   710
    /* Activate an orthographic projection */
slouken@5201
   711
    if (GLES2_SetOrthographicProjection(renderer) < 0)
slouken@5201
   712
        goto fault;
slouken@5201
   713
slouken@5201
   714
    /* Clean up and return */
slouken@5201
   715
    return 0;
slouken@5201
   716
fault:
slouken@5201
   717
    if (vertex && vertex->references <= 0)
slouken@5201
   718
        GLES2_EvictShader(renderer, vertex);
slouken@5201
   719
    if (fragment && fragment->references <= 0)
slouken@5201
   720
        GLES2_EvictShader(renderer, fragment);
slouken@5201
   721
    rdata->current_program = NULL;
slouken@5201
   722
    return -1;
slouken@5201
   723
}
slouken@5201
   724
slouken@5201
   725
static int
slouken@5201
   726
GLES2_SetOrthographicProjection(SDL_Renderer *renderer)
slouken@5201
   727
{
slouken@5201
   728
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   729
    SDL_Window *window = renderer->window;
slouken@5201
   730
    int w, h;
slouken@5201
   731
    GLfloat projection[4][4];
slouken@5201
   732
    GLuint locProjection;
slouken@5201
   733
slouken@5201
   734
    /* Get the window width and height */
slouken@5201
   735
    SDL_GetWindowSize(window, &w, &h);
slouken@5201
   736
slouken@5201
   737
    /* Prepare an orthographic projection */
slouken@5201
   738
    projection[0][0] = 2.0f / w;
slouken@5201
   739
    projection[0][1] = 0.0f;
slouken@5201
   740
    projection[0][2] = 0.0f;
slouken@5201
   741
    projection[0][3] = 0.0f;
slouken@5201
   742
    projection[1][0] = 0.0f;
slouken@5201
   743
    projection[1][1] = -2.0f / h;
slouken@5201
   744
    projection[1][2] = 0.0f;
slouken@5201
   745
    projection[1][3] = 0.0f;
slouken@5201
   746
    projection[2][0] = 0.0f;
slouken@5201
   747
    projection[2][1] = 0.0f;
slouken@5201
   748
    projection[2][2] = 1.0f;
slouken@5201
   749
    projection[2][3] = 0.0f;
slouken@5201
   750
    projection[3][0] = -1.0f;
slouken@5201
   751
    projection[3][1] = 1.0f;
slouken@5201
   752
    projection[3][2] = 0.0f;
slouken@5201
   753
    projection[3][3] = 1.0f;
slouken@5201
   754
slouken@5201
   755
    /* Set the projection matrix */
slouken@5201
   756
    locProjection = rdata->current_program->uniform_locations[GLES2_UNIFORM_PROJECTION];
slouken@5201
   757
    glGetError();
slouken@5201
   758
    glUniformMatrix4fv(locProjection, 1, GL_FALSE, (GLfloat *)projection);
slouken@5201
   759
    if (glGetError() != GL_NO_ERROR)
slouken@5201
   760
    {
slouken@5201
   761
        SDL_SetError("Failed to set orthographic projection");
slouken@5201
   762
        return -1;
slouken@5201
   763
    }
slouken@5201
   764
    return 0;
slouken@5201
   765
}
slouken@5201
   766
slouken@5201
   767
/*************************************************************************************************
slouken@5201
   768
 * Rendering functions                                                                           *
slouken@5201
   769
 *************************************************************************************************/
slouken@5201
   770
slouken@5201
   771
static int GLES2_RenderClear(SDL_Renderer *renderer);
slouken@5201
   772
static int GLES2_RenderDrawPoints(SDL_Renderer *renderer, const SDL_Point *points, int count);
slouken@5201
   773
static int GLES2_RenderDrawLines(SDL_Renderer *renderer, const SDL_Point *points, int count);
slouken@5201
   774
static int GLES2_RenderDrawRects(SDL_Renderer *renderer, const SDL_Rect **rects, int count);
slouken@5201
   775
static int GLES2_RenderFillRects(SDL_Renderer *renderer, const SDL_Rect **rects, int count);
slouken@5201
   776
static int GLES2_RenderCopy(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect,
slouken@5201
   777
                            const SDL_Rect *dstrect);
slouken@5201
   778
static void GLES2_RenderPresent(SDL_Renderer *renderer);
slouken@5201
   779
slouken@5201
   780
static int
slouken@5201
   781
GLES2_RenderClear(SDL_Renderer *renderer)
slouken@5201
   782
{
slouken@5201
   783
    float r = (float)renderer->r / 255.0f;
slouken@5201
   784
    float g = (float)renderer->g / 255.0f;
slouken@5201
   785
    float b = (float)renderer->b / 255.0f;
slouken@5201
   786
    float a = (float)renderer->a / 255.0f;
slouken@5201
   787
slouken@5201
   788
    GLES2_ActivateRenderer(renderer);
slouken@5201
   789
slouken@5201
   790
    /* Clear the backbuffer with the selected color */
slouken@5201
   791
    glClearColor(r, g, b, a);
slouken@5201
   792
    glClear(GL_COLOR_BUFFER_BIT);
slouken@5201
   793
    return 0;
slouken@5201
   794
}
slouken@5201
   795
slouken@5201
   796
static void
slouken@5201
   797
GLES2_SetBlendMode(int blendMode)
slouken@5201
   798
{
slouken@5201
   799
    switch (blendMode)
slouken@5201
   800
    {
slouken@5201
   801
    case SDL_BLENDMODE_NONE:
slouken@5201
   802
    default:
slouken@5201
   803
        glDisable(GL_BLEND);
slouken@5201
   804
        break;
slouken@5201
   805
    case SDL_BLENDMODE_BLEND:
slouken@5201
   806
        glEnable(GL_BLEND);
slouken@5201
   807
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
slouken@5201
   808
        break;
slouken@5201
   809
    case SDL_BLENDMODE_ADD:
slouken@5201
   810
        glEnable(GL_BLEND);
slouken@5201
   811
        glBlendFunc(GL_SRC_ALPHA, GL_ONE);
slouken@5201
   812
        break;
slouken@5201
   813
    case SDL_BLENDMODE_MOD:
slouken@5201
   814
        glEnable(GL_BLEND);
slouken@5201
   815
        glBlendFunc(GL_ZERO, GL_SRC_COLOR);
slouken@5201
   816
        break;
slouken@5201
   817
    }
slouken@5201
   818
}
slouken@5201
   819
slouken@5201
   820
static int
slouken@5201
   821
GLES2_RenderDrawPoints(SDL_Renderer *renderer, const SDL_Point *points, int count)
slouken@5201
   822
{
slouken@5201
   823
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   824
    GLfloat *vertices;
slouken@5201
   825
    SDL_BlendMode blendMode;
slouken@5201
   826
    int alpha;
slouken@5201
   827
    GLuint locColor;
slouken@5201
   828
    int idx;
slouken@5201
   829
slouken@5201
   830
    GLES2_ActivateRenderer(renderer);
slouken@5201
   831
slouken@5201
   832
    blendMode = renderer->blendMode;
slouken@5201
   833
    alpha = renderer->a;
slouken@5201
   834
slouken@5201
   835
    /* Activate an appropriate shader and set the projection matrix */
slouken@5201
   836
    if (GLES2_SelectProgram(renderer, GLES2_IMAGESOURCE_SOLID, blendMode) < 0)
slouken@5201
   837
        return -1;
slouken@5201
   838
slouken@5201
   839
    /* Select the color to draw with */
slouken@5201
   840
    locColor = rdata->current_program->uniform_locations[GLES2_UNIFORM_COLOR];
slouken@5201
   841
    glGetError();
slouken@5201
   842
    glUniform4f(locColor,
slouken@5201
   843
                renderer->r / 255.0f,
slouken@5201
   844
                renderer->g / 255.0f,
slouken@5201
   845
                renderer->b / 255.0f,
slouken@5201
   846
                alpha / 255.0f);
slouken@5201
   847
slouken@5201
   848
    /* Configure the correct blend mode */
slouken@5201
   849
    GLES2_SetBlendMode(blendMode);
slouken@5201
   850
slouken@5201
   851
    /* Emit the specified vertices as points */
slouken@5201
   852
    vertices = SDL_stack_alloc(GLfloat, count * 2);
slouken@5201
   853
    for (idx = 0; idx < count; ++idx)
slouken@5201
   854
    {
slouken@5201
   855
        GLfloat x = (GLfloat)points[idx].x + 0.5f;
slouken@5201
   856
        GLfloat y = (GLfloat)points[idx].y + 0.5f;
slouken@5201
   857
slouken@5201
   858
        vertices[idx * 2] = x;
slouken@5201
   859
        vertices[(idx * 2) + 1] = y;
slouken@5201
   860
    }
slouken@5201
   861
    glEnableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
slouken@5201
   862
    glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
slouken@5201
   863
    glDrawArrays(GL_POINTS, 0, count);
slouken@5201
   864
    glDisableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
slouken@5201
   865
    SDL_stack_free(vertices);
slouken@5201
   866
    if (glGetError() != GL_NO_ERROR)
slouken@5201
   867
    {
slouken@5201
   868
        SDL_SetError("Failed to render lines");
slouken@5201
   869
        return -1;
slouken@5201
   870
    }
slouken@5201
   871
    return 0;
slouken@5201
   872
}
slouken@5201
   873
slouken@5201
   874
static int
slouken@5201
   875
GLES2_RenderDrawLines(SDL_Renderer *renderer, const SDL_Point *points, int count)
slouken@5201
   876
{
slouken@5201
   877
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   878
    GLfloat *vertices;
slouken@5201
   879
    SDL_BlendMode blendMode;
slouken@5201
   880
    int alpha;
slouken@5201
   881
    GLuint locColor;
slouken@5201
   882
    int idx;
slouken@5201
   883
slouken@5201
   884
    GLES2_ActivateRenderer(renderer);
slouken@5201
   885
slouken@5201
   886
    blendMode = renderer->blendMode;
slouken@5201
   887
    alpha = renderer->a;
slouken@5201
   888
slouken@5201
   889
    /* Activate an appropriate shader and set the projection matrix */
slouken@5201
   890
    if (GLES2_SelectProgram(renderer, GLES2_IMAGESOURCE_SOLID, blendMode) < 0)
slouken@5201
   891
        return -1;
slouken@5201
   892
slouken@5201
   893
    /* Select the color to draw with */
slouken@5201
   894
    locColor = rdata->current_program->uniform_locations[GLES2_UNIFORM_COLOR];
slouken@5201
   895
    glGetError();
slouken@5201
   896
    glUniform4f(locColor,
slouken@5201
   897
                renderer->r / 255.0f,
slouken@5201
   898
                renderer->g / 255.0f,
slouken@5201
   899
                renderer->b / 255.0f,
slouken@5201
   900
                alpha / 255.0f);
slouken@5201
   901
slouken@5201
   902
    /* Configure the correct blend mode */
slouken@5201
   903
    GLES2_SetBlendMode(blendMode);
slouken@5201
   904
slouken@5201
   905
    /* Emit a line strip including the specified vertices */
slouken@5201
   906
    vertices = SDL_stack_alloc(GLfloat, count * 2);
slouken@5201
   907
    for (idx = 0; idx < count; ++idx)
slouken@5201
   908
    {
slouken@5201
   909
        GLfloat x = (GLfloat)points[idx].x + 0.5f;
slouken@5201
   910
        GLfloat y = (GLfloat)points[idx].y + 0.5f;
slouken@5201
   911
slouken@5201
   912
        vertices[idx * 2] = x;
slouken@5201
   913
        vertices[(idx * 2) + 1] = y;
slouken@5201
   914
    }
slouken@5201
   915
    glEnableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
slouken@5201
   916
    glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
slouken@5201
   917
    glDrawArrays(GL_LINE_STRIP, 0, count);
slouken@5201
   918
    glDisableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
slouken@5201
   919
    SDL_stack_free(vertices);
slouken@5201
   920
    if (glGetError() != GL_NO_ERROR)
slouken@5201
   921
    {
slouken@5201
   922
        SDL_SetError("Failed to render lines");
slouken@5201
   923
        return -1;
slouken@5201
   924
    }
slouken@5201
   925
    return 0;
slouken@5201
   926
}
slouken@5201
   927
slouken@5201
   928
static int
slouken@5201
   929
GLES2_RenderFillRects(SDL_Renderer *renderer, const SDL_Rect **rects, int count)
slouken@5201
   930
{
slouken@5201
   931
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   932
    GLfloat vertices[8];
slouken@5201
   933
    SDL_BlendMode blendMode;
slouken@5201
   934
    int alpha;
slouken@5201
   935
    GLuint locColor;
slouken@5201
   936
    int idx;
slouken@5201
   937
slouken@5201
   938
    GLES2_ActivateRenderer(renderer);
slouken@5201
   939
slouken@5201
   940
    blendMode = renderer->blendMode;
slouken@5201
   941
    alpha = renderer->a;
slouken@5201
   942
slouken@5201
   943
    /* Activate an appropriate shader and set the projection matrix */
slouken@5201
   944
    if (GLES2_SelectProgram(renderer, GLES2_IMAGESOURCE_SOLID, blendMode) < 0)
slouken@5201
   945
        return -1;
slouken@5201
   946
slouken@5201
   947
    /* Select the color to draw with */
slouken@5201
   948
    locColor = rdata->current_program->uniform_locations[GLES2_UNIFORM_COLOR];
slouken@5201
   949
    glGetError();
slouken@5201
   950
    glUniform4f(locColor,
slouken@5201
   951
                renderer->r / 255.0f,
slouken@5201
   952
                renderer->g / 255.0f,
slouken@5201
   953
                renderer->b / 255.0f,
slouken@5201
   954
                alpha / 255.0f);
slouken@5201
   955
slouken@5201
   956
    /* Configure the correct blend mode */
slouken@5201
   957
    GLES2_SetBlendMode(blendMode);
slouken@5201
   958
slouken@5201
   959
    /* Emit a line loop for each rectangle */
slouken@5201
   960
    glEnableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
slouken@5201
   961
    for (idx = 0; idx < count; ++idx)
slouken@5201
   962
    {
slouken@5201
   963
        GLfloat xMin = (GLfloat)rects[idx]->x;
slouken@5201
   964
        GLfloat xMax = (GLfloat)(rects[idx]->x + rects[idx]->w);
slouken@5201
   965
        GLfloat yMin = (GLfloat)rects[idx]->y;
slouken@5201
   966
        GLfloat yMax = (GLfloat)(rects[idx]->y + rects[idx]->h);
slouken@5201
   967
slouken@5201
   968
        vertices[0] = xMin;
slouken@5201
   969
        vertices[1] = yMin;
slouken@5201
   970
        vertices[2] = xMax;
slouken@5201
   971
        vertices[3] = yMin;
slouken@5201
   972
        vertices[4] = xMin;
slouken@5201
   973
        vertices[5] = yMax;
slouken@5201
   974
        vertices[6] = xMax;
slouken@5201
   975
        vertices[7] = yMax;
slouken@5201
   976
        glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
slouken@5201
   977
        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
slouken@5201
   978
    }
slouken@5201
   979
    glDisableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
slouken@5201
   980
    if (glGetError() != GL_NO_ERROR)
slouken@5201
   981
    {
slouken@5201
   982
        SDL_SetError("Failed to render lines");
slouken@5201
   983
        return -1;
slouken@5201
   984
    }
slouken@5201
   985
    return 0;
slouken@5201
   986
}
slouken@5201
   987
slouken@5201
   988
static int
slouken@5201
   989
GLES2_RenderCopy(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect,
slouken@5201
   990
                 const SDL_Rect *dstrect)
slouken@5201
   991
{
slouken@5201
   992
    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;
slouken@5201
   993
    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
slouken@5201
   994
    GLES2_ImageSource sourceType;
slouken@5201
   995
    SDL_BlendMode blendMode;
slouken@5201
   996
    int alpha;
slouken@5201
   997
    GLfloat vertices[8];
slouken@5201
   998
    GLfloat texCoords[8];
slouken@5201
   999
    GLuint locTexture;
slouken@5201
  1000
    GLuint locModulation;
slouken@5201
  1001
    GLuint locColorTable;
slouken@5201
  1002
slouken@5201
  1003
    GLES2_ActivateRenderer(renderer);
slouken@5201
  1004
slouken@5201
  1005
    /* Activate an appropriate shader and set the projection matrix */
slouken@5201
  1006
    blendMode = texture->blendMode;
slouken@5201
  1007
    alpha = texture->a;
slouken@5201
  1008
    sourceType = GLES2_IMAGESOURCE_TEXTURE;
slouken@5201
  1009
    if (GLES2_SelectProgram(renderer, sourceType, blendMode) < 0)
slouken@5201
  1010
        return -1;
slouken@5201
  1011
slouken@5201
  1012
    /* Select the target texture */
slouken@5201
  1013
    locTexture = rdata->current_program->uniform_locations[GLES2_UNIFORM_TEXTURE];
slouken@5201
  1014
    glGetError();
slouken@5201
  1015
    glActiveTexture(GL_TEXTURE0);
slouken@5201
  1016
    glBindTexture(tdata->texture_type, tdata->texture);
slouken@5201
  1017
    glUniform1i(locTexture, 0);
slouken@5201
  1018
slouken@5201
  1019
    /* Configure texture blending */
slouken@5201
  1020
    GLES2_SetBlendMode(blendMode);
slouken@5201
  1021
slouken@5201
  1022
    /* Configure color modulation */
slouken@5201
  1023
    locModulation = rdata->current_program->uniform_locations[GLES2_UNIFORM_MODULATION];
slouken@5201
  1024
    glUniform4f(locModulation,
slouken@5201
  1025
                texture->r / 255.0f,
slouken@5201
  1026
                texture->g / 255.0f,
slouken@5201
  1027
                texture->b / 255.0f,
slouken@5201
  1028
                alpha / 255.0f);
slouken@5201
  1029
slouken@5201
  1030
    /* Emit the textured quad */
slouken@5201
  1031
    glEnableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
slouken@5201
  1032
    glEnableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
slouken@5201
  1033
    vertices[0] = (GLfloat)dstrect->x;
slouken@5201
  1034
    vertices[1] = (GLfloat)dstrect->y;
slouken@5201
  1035
    vertices[2] = (GLfloat)(dstrect->x + dstrect->w);
slouken@5201
  1036
    vertices[3] = (GLfloat)dstrect->y;
slouken@5201
  1037
    vertices[4] = (GLfloat)dstrect->x;
slouken@5201
  1038
    vertices[5] = (GLfloat)(dstrect->y + dstrect->h);
slouken@5201
  1039
    vertices[6] = (GLfloat)(dstrect->x + dstrect->w);
slouken@5201
  1040
    vertices[7] = (GLfloat)(dstrect->y + dstrect->h);
slouken@5201
  1041
    glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
slouken@5201
  1042
    texCoords[0] = srcrect->x / (GLfloat)texture->w;
slouken@5201
  1043
    texCoords[1] = srcrect->y / (GLfloat)texture->h;
slouken@5201
  1044
    texCoords[2] = (srcrect->x + srcrect->w) / (GLfloat)texture->w;
slouken@5201
  1045
    texCoords[3] = srcrect->y / (GLfloat)texture->h;
slouken@5201
  1046
    texCoords[4] = srcrect->x / (GLfloat)texture->w;
slouken@5201
  1047
    texCoords[5] = (srcrect->y + srcrect->h) / (GLfloat)texture->h;
slouken@5201
  1048
    texCoords[6] = (srcrect->x + srcrect->w) / (GLfloat)texture->w;
slouken@5201
  1049
    texCoords[7] = (srcrect->y + srcrect->h) / (GLfloat)texture->h;
slouken@5201
  1050
    glVertexAttribPointer(GLES2_ATTRIBUTE_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 0, texCoords);
slouken@5201
  1051
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
slouken@5201
  1052
    glDisableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
slouken@5201
  1053
    glDisableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
slouken@5201
  1054
    if (glGetError() != GL_NO_ERROR)
slouken@5201
  1055
    {
slouken@5201
  1056
        SDL_SetError("Failed to render texture");
slouken@5201
  1057
        return -1;
slouken@5201
  1058
    }
slouken@5201
  1059
    return 0;
slouken@5201
  1060
}
slouken@5201
  1061
slouken@5201
  1062
static void
slouken@5201
  1063
GLES2_RenderPresent(SDL_Renderer *renderer)
slouken@5201
  1064
{
slouken@5201
  1065
    GLES2_ActivateRenderer(renderer);
slouken@5201
  1066
slouken@5201
  1067
    /* Tell the video driver to swap buffers */
slouken@5201
  1068
    SDL_GL_SwapWindow(renderer->window);
slouken@5201
  1069
}
slouken@5201
  1070
slouken@5201
  1071
/*************************************************************************************************
slouken@5201
  1072
 * Renderer instantiation                                                                        *
slouken@5201
  1073
 *************************************************************************************************/
slouken@5201
  1074
slouken@5201
  1075
#define GL_NVIDIA_PLATFORM_BINARY_NV 0x890B
slouken@5201
  1076
slouken@5201
  1077
static SDL_Renderer *
slouken@5201
  1078
GLES2_CreateRenderer(SDL_Window *window, Uint32 flags)
slouken@5201
  1079
{
slouken@5201
  1080
    SDL_Renderer *renderer;
slouken@5201
  1081
    GLES2_DriverContext *rdata;
slouken@5201
  1082
    GLint nFormats;
slouken@5201
  1083
#ifndef ZUNE_HD
slouken@5201
  1084
    GLboolean hasCompiler;
slouken@5201
  1085
#endif
slouken@5201
  1086
slouken@5201
  1087
    /* Create the renderer struct */
slouken@5201
  1088
    renderer = (SDL_Renderer *)SDL_calloc(1, sizeof(SDL_Renderer));
slouken@5201
  1089
    rdata = (GLES2_DriverContext *)SDL_calloc(1, sizeof(GLES2_DriverContext));
slouken@5201
  1090
    if (!renderer)
slouken@5201
  1091
    {
slouken@5201
  1092
        SDL_OutOfMemory();
slouken@5201
  1093
        SDL_free(renderer);
slouken@5201
  1094
        SDL_free(rdata);
slouken@5201
  1095
        return NULL;
slouken@5201
  1096
    }
slouken@5201
  1097
    renderer->info = GLES2_RenderDriver.info;
slouken@5201
  1098
    renderer->window = window;
slouken@5201
  1099
    renderer->driverdata = rdata;
slouken@5201
  1100
slouken@5201
  1101
    /* Create the GL context */
slouken@5201
  1102
    rdata->context = SDL_GL_CreateContext(window);
slouken@5201
  1103
    if (!rdata->context)
slouken@5201
  1104
    {
slouken@5201
  1105
        SDL_free(renderer);
slouken@5201
  1106
        SDL_free(rdata);
slouken@5201
  1107
        return NULL;
slouken@5201
  1108
    }
slouken@5202
  1109
    if (SDL_GL_MakeCurrent(window, rdata->context) < 0) {
slouken@5202
  1110
        SDL_free(renderer);
slouken@5202
  1111
        SDL_free(rdata);
slouken@5202
  1112
        return NULL;
slouken@5202
  1113
    }
slouken@5202
  1114
slouken@5202
  1115
    if (flags & SDL_RENDERER_PRESENTVSYNC) {
slouken@5202
  1116
        SDL_GL_SetSwapInterval(1);
slouken@5202
  1117
    } else {
slouken@5202
  1118
        SDL_GL_SetSwapInterval(0);
slouken@5202
  1119
    }
slouken@5202
  1120
    if (SDL_GL_GetSwapInterval() > 0) {
slouken@5202
  1121
        renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
slouken@5202
  1122
    }
slouken@5201
  1123
slouken@5201
  1124
    /* Determine supported shader formats */
slouken@5201
  1125
    /* HACK: glGetInteger is broken on the Zune HD's compositor, so we just hardcode this */
slouken@5201
  1126
    glGetError();
slouken@5201
  1127
#ifdef ZUNE_HD
slouken@5201
  1128
    nFormats = 1;
slouken@5201
  1129
#else /* !ZUNE_HD */
slouken@5201
  1130
    glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &nFormats);
slouken@5201
  1131
    glGetBooleanv(GL_SHADER_COMPILER, &hasCompiler);
slouken@5201
  1132
    if (hasCompiler)
slouken@5201
  1133
        ++nFormats;
slouken@5201
  1134
#endif /* ZUNE_HD */
slouken@5201
  1135
    rdata->shader_formats = (GLenum *)SDL_calloc(nFormats, sizeof(GLenum));
slouken@5201
  1136
    if (!rdata->shader_formats)
slouken@5201
  1137
    {
slouken@5201
  1138
        SDL_OutOfMemory();
slouken@5201
  1139
        SDL_free(renderer);
slouken@5201
  1140
        SDL_free(rdata);
slouken@5201
  1141
        return NULL;
slouken@5201
  1142
    }
slouken@5201
  1143
    rdata->shader_format_count = nFormats;
slouken@5201
  1144
#ifdef ZUNE_HD
slouken@5201
  1145
    rdata->shader_formats[0] = GL_NVIDIA_PLATFORM_BINARY_NV;
slouken@5201
  1146
#else /* !ZUNE_HD */
slouken@5201
  1147
    glGetIntegerv(GL_SHADER_BINARY_FORMATS, (GLint *)rdata->shader_formats);
slouken@5201
  1148
    if (glGetError() != GL_NO_ERROR)
slouken@5201
  1149
    {
slouken@5201
  1150
        SDL_SetError("Failed to query supported shader formats");
slouken@5201
  1151
        SDL_free(renderer);
slouken@5201
  1152
        SDL_free(rdata->shader_formats);
slouken@5201
  1153
        SDL_free(rdata);
slouken@5201
  1154
        return NULL;
slouken@5201
  1155
    }
slouken@5201
  1156
    if (hasCompiler)
slouken@5201
  1157
        rdata->shader_formats[nFormats - 1] = (GLenum)-1;
slouken@5201
  1158
#endif /* ZUNE_HD */
slouken@5201
  1159
slouken@5201
  1160
    /* Populate the function pointers for the module */
slouken@5201
  1161
    renderer->WindowEvent         = &GLES2_WindowEvent;
slouken@5201
  1162
    renderer->CreateTexture       = &GLES2_CreateTexture;
slouken@5201
  1163
    renderer->UpdateTexture       = &GLES2_UpdateTexture;
slouken@5201
  1164
    renderer->LockTexture         = &GLES2_LockTexture;
slouken@5201
  1165
    renderer->UnlockTexture       = &GLES2_UnlockTexture;
slouken@5201
  1166
    renderer->RenderClear         = &GLES2_RenderClear;
slouken@5201
  1167
    renderer->RenderDrawPoints    = &GLES2_RenderDrawPoints;
slouken@5201
  1168
    renderer->RenderDrawLines     = &GLES2_RenderDrawLines;
slouken@5201
  1169
    renderer->RenderFillRects     = &GLES2_RenderFillRects;
slouken@5201
  1170
    renderer->RenderCopy          = &GLES2_RenderCopy;
slouken@5201
  1171
    renderer->RenderPresent       = &GLES2_RenderPresent;
slouken@5201
  1172
    renderer->DestroyTexture      = &GLES2_DestroyTexture;
slouken@5201
  1173
    renderer->DestroyRenderer     = &GLES2_DestroyRenderer;
slouken@5201
  1174
    return renderer;
slouken@5201
  1175
}
slouken@5201
  1176
slouken@5201
  1177
#endif /* SDL_VIDEO_RENDER_OGL_ES2 */
slouken@5201
  1178
slouken@5201
  1179
/* vi: set ts=4 sw=4 expandtab: */