/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2011 Sam Lantinga

    Copyright (C) 2010 itsnotabigtruck.

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Lesser General Public

    License as published by the Free Software Foundation; either

    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public

    License along with this library; if not, write to the Free Software

    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga

    slouken@libsdl.org

*/

#include "SDL_config.h"

#if SDL_VIDEO_RENDER_OGL_ES2 && !SDL_RENDER_DISABLED

#include "SDL_opengles2.h"

#include "../SDL_sysrender.h"

#include "SDL_shaders_gles2.h"

/*************************************************************************************************

 * Bootstrap data                                                                                *

 *************************************************************************************************/

static SDL_Renderer *GLES2_CreateRenderer(SDL_Window *window, Uint32 flags);

SDL_RenderDriver GLES2_RenderDriver = {

    GLES2_CreateRenderer,

    {

        "opengles2",

        (SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC),

        1,

        {SDL_PIXELFORMAT_ABGR8888},

        0,

        0

    }

};

/*************************************************************************************************

 * Context structures                                                                            *

 *************************************************************************************************/

typedef struct GLES2_TextureData

{

    GLenum texture;

    GLenum texture_type;

    GLenum pixel_format;

    GLenum pixel_type;

    void *pixel_data;

    size_t pitch;

    GLenum scaleMode;

} GLES2_TextureData;

typedef struct GLES2_ShaderCacheEntry

{

    GLuint id;

    GLES2_ShaderType type;

    const GLES2_ShaderInstance *instance;

    int references;

    struct GLES2_ShaderCacheEntry *prev;

    struct GLES2_ShaderCacheEntry *next;

} GLES2_ShaderCacheEntry;

typedef struct GLES2_ShaderCache

{

    int count;

    GLES2_ShaderCacheEntry *head;

} GLES2_ShaderCache;

typedef struct GLES2_ProgramCacheEntry

{

    GLuint id;

    SDL_BlendMode blend_mode;

    GLES2_ShaderCacheEntry *vertex_shader;

    GLES2_ShaderCacheEntry *fragment_shader;

    GLuint uniform_locations[16];

    struct GLES2_ProgramCacheEntry *prev;

    struct GLES2_ProgramCacheEntry *next;

} GLES2_ProgramCacheEntry;

typedef struct GLES2_ProgramCache

{

    int count;

    GLES2_ProgramCacheEntry *head;

    GLES2_ProgramCacheEntry *tail;

} GLES2_ProgramCache;

typedef enum

{

    GLES2_ATTRIBUTE_POSITION = 0,

    GLES2_ATTRIBUTE_TEXCOORD = 1

} GLES2_Attribute;

typedef enum

{

    GLES2_UNIFORM_PROJECTION,

    GLES2_UNIFORM_TEXTURE,

    GLES2_UNIFORM_MODULATION,

    GLES2_UNIFORM_COLOR,

    GLES2_UNIFORM_COLORTABLE

} GLES2_Uniform;

typedef enum

{

    GLES2_IMAGESOURCE_SOLID,

    GLES2_IMAGESOURCE_TEXTURE

} GLES2_ImageSource;

typedef struct GLES2_DriverContext

{

    SDL_GLContext *context;

    struct {

        int blendMode;

        GLenum scaleMode;

        SDL_bool tex_coords;

    } current;

    int shader_format_count;

    GLenum *shader_formats;

    GLES2_ShaderCache shader_cache;

    GLES2_ProgramCache program_cache;

    GLES2_ProgramCacheEntry *current_program;

} GLES2_DriverContext;

#define GLES2_MAX_CACHED_PROGRAMS 8

/*************************************************************************************************

 * Renderer state APIs                                                                           *

 *************************************************************************************************/

static int GLES2_ActivateRenderer(SDL_Renderer *renderer);

static void GLES2_WindowEvent(SDL_Renderer * renderer,

                              const SDL_WindowEvent *event);

static int GLES2_UpdateViewport(SDL_Renderer * renderer);

static void GLES2_DestroyRenderer(SDL_Renderer *renderer);

static SDL_GLContext SDL_CurrentContext = NULL;

static int

GLES2_ActivateRenderer(SDL_Renderer * renderer)

{

    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;

    if (SDL_CurrentContext != rdata->context) {

        /* Null out the current program to ensure we set it again */

        rdata->current_program = NULL;

        if (SDL_GL_MakeCurrent(renderer->window, rdata->context) < 0) {

            return -1;

        }

        SDL_CurrentContext = rdata->context;

        GLES2_UpdateViewport(renderer);

    }

    return 0;

}

static void

GLES2_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)

{

    if (event->event == SDL_WINDOWEVENT_SIZE_CHANGED) {

        /* Rebind the context to the window area */

        SDL_CurrentContext = NULL;

    }

}

static int

GLES2_UpdateViewport(SDL_Renderer * renderer)

{

    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;

    if (SDL_CurrentContext != rdata->context) {

        /* We'll update the viewport after we rebind the context */

        return 0;

    }

    glViewport(renderer->viewport.x, renderer->viewport.y,

               renderer->viewport.w, renderer->viewport.h);

    return 0;

}

static void

GLES2_DestroyRenderer(SDL_Renderer *renderer)

{

    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;

    GLES2_ProgramCacheEntry *entry;

    GLES2_ProgramCacheEntry *next;

    /* Deallocate everything */

    if (rdata) {

        GLES2_ActivateRenderer(renderer);

        entry = rdata->program_cache.head;

        while (entry) {

            glDeleteShader(entry->vertex_shader->id);

            glDeleteShader(entry->fragment_shader->id);

            SDL_free(entry->vertex_shader);

            SDL_free(entry->fragment_shader);

            glDeleteProgram(entry->id);

            next = entry->next;

            SDL_free(entry);

            entry = next;

        }

        if (rdata->context) {

            SDL_GL_DeleteContext(rdata->context);

        }

        if (rdata->shader_formats) {

            SDL_free(rdata->shader_formats);

        }

        SDL_free(rdata);

    }

    SDL_free(renderer);

}

/*************************************************************************************************

 * Texture APIs                                                                                  *

 *************************************************************************************************/

static int GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture);

static void GLES2_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture);

static int GLES2_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,

                             void **pixels, int *pitch);

static void GLES2_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture);

static int GLES2_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,

                               const void *pixels, int pitch);

static int

GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)

{

    GLES2_TextureData *tdata;

    GLenum format;

    GLenum type;

    GLES2_ActivateRenderer(renderer);

    /* Determine the corresponding GLES texture format params */

    switch (texture->format)

    {

    case SDL_PIXELFORMAT_ABGR8888:

        format = GL_RGBA;

        type = GL_UNSIGNED_BYTE;

        break;

    default:

        SDL_SetError("Texture format not supported");

        return -1;

    }

    /* Allocate a texture struct */

    tdata = (GLES2_TextureData *)SDL_calloc(1, sizeof(GLES2_TextureData));

    if (!tdata)

    {

        SDL_OutOfMemory();

        return -1;

    }

    tdata->texture = 0;

    tdata->texture_type = GL_TEXTURE_2D;

    tdata->pixel_format = format;

    tdata->pixel_type = type;

    tdata->scaleMode = GL_LINEAR;

    /* Allocate a blob for image data */

    if (texture->access == SDL_TEXTUREACCESS_STREAMING)

    {

        tdata->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);

        if (!tdata->pixel_data)

        {

            SDL_OutOfMemory();

            SDL_free(tdata);

            return -1;

        }

    }

    /* Allocate the texture */

    glGetError();

    glGenTextures(1, &tdata->texture);

    glActiveTexture(GL_TEXTURE0);

    glBindTexture(tdata->texture_type, tdata->texture);

    glTexParameteri(tdata->texture_type, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    glTexParameteri(tdata->texture_type, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    glTexParameteri(tdata->texture_type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

    glTexParameteri(tdata->texture_type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glTexImage2D(tdata->texture_type, 0, format, texture->w, texture->h, 0, format, type, NULL);

    if (glGetError() != GL_NO_ERROR)

    {

        SDL_SetError("Texture creation failed");

        glDeleteTextures(1, &tdata->texture);

        SDL_free(tdata);

        return -1;

    }

    texture->driverdata = tdata;

    return 0;

}

static void

GLES2_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)

{

    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;

    GLES2_ActivateRenderer(renderer);

    /* Destroy the texture */

    if (tdata)

    {

        glDeleteTextures(1, &tdata->texture);

        SDL_free(tdata->pixel_data);

        SDL_free(tdata);

        texture->driverdata = NULL;

    }

}

static int

GLES2_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,

                  void **pixels, int *pitch)

{

    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;

    /* Retrieve the buffer/pitch for the specified region */

    *pixels = (Uint8 *)tdata->pixel_data +

              (tdata->pitch * rect->y) +

              (rect->x * SDL_BYTESPERPIXEL(texture->format));

    *pitch = tdata->pitch;

    return 0;

}

static void

GLES2_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)

{

    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;

    SDL_Rect rect;

    /* We do whole texture updates, at least for now */

    rect.x = 0;

    rect.y = 0;

    rect.w = texture->w;

    rect.h = texture->h;

    GLES2_UpdateTexture(renderer, texture, &rect, tdata->pixel_data, tdata->pitch);

}

static int

GLES2_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,

                    const void *pixels, int pitch)

{

    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;

    Uint8 *blob = NULL;

    Uint8 *src;

    int srcPitch;

    int y;

    GLES2_ActivateRenderer(renderer);

    /* Bail out if we're supposed to update an empty rectangle */

    if (rect->w <= 0 || rect->h <= 0)

        return 0;

    /* Reformat the texture data into a tightly packed array */

    srcPitch = rect->w * SDL_BYTESPERPIXEL(texture->format);

    src = (Uint8 *)pixels;

    if (pitch != srcPitch)

    {

        blob = (Uint8 *)SDL_malloc(srcPitch * rect->h);

        if (!blob)

        {

            SDL_OutOfMemory();

            return -1;

        }

        src = blob;

        for (y = 0; y < rect->h; ++y)

        {

            SDL_memcpy(src, pixels, srcPitch);

            src += srcPitch;

            pixels = (Uint8 *)pixels + pitch;

        }

        src = blob;

    }

    /* Create a texture subimage with the supplied data */

    glGetError();

    glActiveTexture(GL_TEXTURE0);

    glBindTexture(tdata->texture_type, tdata->texture);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

    glTexSubImage2D(tdata->texture_type,

                    0,

                    rect->x,

                    rect->y,

                    rect->w,

                    rect->h,

                    tdata->pixel_format,

                    tdata->pixel_type,

                    src);

    if (blob) {

        SDL_free(blob);

    }

    if (glGetError() != GL_NO_ERROR)

    {

        SDL_SetError("Failed to update texture");

        return -1;

    }

    return 0;

}

/*************************************************************************************************

 * Shader management functions                                                                   *

 *************************************************************************************************/

static GLES2_ShaderCacheEntry *GLES2_CacheShader(SDL_Renderer *renderer, GLES2_ShaderType type,

                                                 SDL_BlendMode blendMode);

static void GLES2_EvictShader(SDL_Renderer *renderer, GLES2_ShaderCacheEntry *entry);

static GLES2_ProgramCacheEntry *GLES2_CacheProgram(SDL_Renderer *renderer,

                                                   GLES2_ShaderCacheEntry *vertex,

                                                   GLES2_ShaderCacheEntry *fragment,

                                                   SDL_BlendMode blendMode);

static int GLES2_SelectProgram(SDL_Renderer *renderer, GLES2_ImageSource source,

                               SDL_BlendMode blendMode);

static int GLES2_SetOrthographicProjection(SDL_Renderer *renderer);

static GLES2_ProgramCacheEntry *

GLES2_CacheProgram(SDL_Renderer *renderer, GLES2_ShaderCacheEntry *vertex,

                   GLES2_ShaderCacheEntry *fragment, SDL_BlendMode blendMode)

{

    GLES2_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;

    GLES2_ProgramCacheEntry *entry;

    GLES2_ShaderCacheEntry *shaderEntry;

    GLint linkSuccessful;

    /* Check if we've already cached this program */

    entry = rdata->program_cache.head;

    while (entry)

    {

        if (entry->vertex_shader == vertex && entry->fragment_shader == fragment)

            break;

        entry = entry->next;

    }

    if (entry)

    {

        if (rdata->program_cache.count > 1)

        {

            if (entry->next)

                entry->next->prev = entry->prev;

            if (entry->prev)

                entry->prev->next = entry->next;

            entry->prev = NULL;

            entry->next = rdata->program_cache.head;

            rdata->program_cache.head->prev = entry;

            rdata->program_cache.head = entry;

        }

        return entry;

    }

    /* Create a program cache entry */

    entry = (GLES2_ProgramCacheEntry *)SDL_calloc(1, sizeof(GLES2_ProgramCacheEntry));

    if (!entry)

    {

        SDL_OutOfMemory();

        return NULL;

    }

    entry->vertex_shader = vertex;

    entry->fragment_shader = fragment;

    entry->blend_mode = blendMode;

    /* Create the program and link it */

    glGetError();

    entry->id = glCreateProgram();

    glAttachShader(entry->id, vertex->id);

    glAttachShader(entry->id, fragment->id);

    glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_POSITION, "a_position");

    glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_TEXCOORD, "a_texCoord");

    glLinkProgram(entry->id);

    glGetProgramiv(entry->id, GL_LINK_STATUS, &linkSuccessful);

    if (glGetError() != GL_NO_ERROR || !linkSuccessful)

    {

        SDL_SetError("Failed to link shader program");

        glDeleteProgram(entry->id);

        SDL_free(entry);

        return NULL;

    }

    /* Predetermine locations of uniform variables */

    entry->uniform_locations[GLES2_UNIFORM_PROJECTION] =

        glGetUniformLocation(entry->id, "u_projection");

    entry->uniform_locations[GLES2_UNIFORM_TEXTURE] =

        glGetUniformLocation(entry->id, "u_texture");

    entry->uniform_locations[GLES2_UNIFORM_MODULATION] =

        glGetUniformLocation(entry->id, "u_modulation");

    entry->uniform_locations[GLES2_UNIFORM_COLOR] =

        glGetUniformLocation(entry->id, "u_color");

    entry->uniform_locations[GLES2_UNIFORM_COLORTABLE] =

        glGetUniformLocation(entry->id, "u_colorTable");

    /* Cache the linked program */

    if (rdata->program_cache.head)

    {

        entry->next = rdata->program_cache.head;

        rdata->program_cache.head->prev = entry;

    }

    else

    {

        rdata->program_cache.tail = entry;

    }

    rdata->program_cache.head = entry;

    ++rdata->program_cache.count;

    /* Increment the refcount of the shaders we're using */

    ++vertex->references;

    ++fragment->references;

    /* Evict the last entry from the cache if we exceed the limit */

    if (rdata->program_cache.count > GLES2_MAX_CACHED_PROGRAMS)