/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 2010 itsnotabigtruck.

    Permission is hereby granted, free of charge, to any person obtaining a

    copy of this software and associated documentation files (the "Software"),

    to deal in the Software without restriction, including without limitation

    the rights to use, copy, modify, merge, publish, distribute, sublicense,

    and/or sell copies of the Software, and to permit persons to whom the

    Software is furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in

    all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

    DEALINGS IN THE SOFTWARE.

*/

#include "SDL_config.h"

#if SDL_VIDEO_RENDER_OGL_ES2

#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;

} 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;

    int shader_format_count;

    GLenum *shader_formats;

    GLES2_ShaderCache shader_cache;

    GLES2_ProgramCache program_cache;

    GLES2_ProgramCacheEntry *current_program;

	SDL_bool updateSize;

} GLES2_DriverContext;

#define GLES2_MAX_CACHED_PROGRAMS 8

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

 * Renderer state APIs                                                                           *

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

static void GLES2_WindowEvent(SDL_Renderer * renderer,

                              const SDL_WindowEvent *event);

static int GLES2_ActivateRenderer(SDL_Renderer *renderer);

static int GLES2_DisplayModeChanged(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;

    SDL_Window *window = renderer->window;

    if (SDL_CurrentContext != rdata->context) {

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

        rdata->current_program = NULL;

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

            return -1;

        }

        SDL_CurrentContext = rdata->context;

    }

    if (rdata->updateSize) {

        int w, h;

        SDL_GetWindowSize(window, &w, &h);

        glViewport(0, 0, w, h);

        rdata->updateSize = SDL_FALSE;

    }

    return 0;

}

static void

GLES2_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)

{

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

    if (event->event == SDL_WINDOWEVENT_RESIZED) {

        /* Rebind the context to the window area */

        SDL_CurrentContext = NULL;

        rdata->updateSize = SDL_TRUE;

    }

}

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_DriverContext *rdata = (GLES2_DriverContext *)renderer->driverdata;

    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;

    /* Allocate a blob for image data */

    if (texture->access == SDL_TEXTUREACCESS_STREAMING)

    {

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

        tdata->pixel_data = SDL_malloc(tdata->pitch * texture->h);

        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;

    GLES2_ActivateRenderer(renderer);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

    glActiveTexture(GL_TEXTURE0);

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

    glTexSubImage2D(tdata->texture_type, 0, 0, 0, texture->w, texture->h,

                    tdata->pixel_format, tdata->pixel_type, tdata->pixel_data);

}

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;

    Uint8 *dest;

    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 (glGetError() != GL_NO_ERROR)

    {

        SDL_SetError("Failed to update texture");

        return -1;

    }

    /* Update the (streaming) texture buffer, in one pass if possible */

    if (tdata->pixel_data)

    {

        dest = (Uint8 *)tdata->pixel_data +

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

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

        if (rect->w == texture->w)

        {

            SDL_memcpy(dest, src, srcPitch * rect->h);

        }

        else

        {

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

            {

                SDL_memcpy(dest, src, srcPitch);

                src += srcPitch;

                dest += tdata->pitch;

            }

        }

    }

    /* Clean up and return */

    SDL_free(blob);

    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;