/*

  Simple DirectMedia Layer

  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>

  This software is provided 'as-is', without any express or implied

  warranty.  In no event will the authors be held liable for any damages

  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,

  including commercial applications, and to alter it and redistribute it

  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not

     claim that you wrote the original software. If you use this software

     in a product, an acknowledgment in the product documentation would be

     appreciated but is not required.

  2. Altered source versions must be plainly marked as such, and must not be

     misrepresented as being the original software.

  3. This notice may not be removed or altered from any source distribution.

*/

#include "SDL_config.h"

#if SDL_VIDEO_RENDER_OGL && !SDL_RENDER_DISABLED

#include "SDL_hints.h"

#include "SDL_log.h"

#include "SDL_opengl.h"

#include "../SDL_sysrender.h"

#include "SDL_shaders_gl.h"

#ifdef __MACOSX__

#include <OpenGL/OpenGL.h>

#endif

/* OpenGL renderer implementation */

/* Details on optimizing the texture path on Mac OS X:

   http://developer.apple.com/library/mac/#documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_texturedata/opengl_texturedata.html

*/

/* Used to re-create the window with OpenGL capability */

extern int SDL_RecreateWindow(SDL_Window * window, Uint32 flags);

static const float inv255f = 1.0f / 255.0f;

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

static void GL_WindowEvent(SDL_Renderer * renderer,

                           const SDL_WindowEvent *event);

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

static int GL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,

                            const SDL_Rect * rect, const void *pixels,

                            int pitch);

static int GL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,

                          const SDL_Rect * rect, void **pixels, int *pitch);

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

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

static int GL_UpdateViewport(SDL_Renderer * renderer);

static int GL_UpdateClipRect(SDL_Renderer * renderer);

static int GL_RenderClear(SDL_Renderer * renderer);

static int GL_RenderDrawPoints(SDL_Renderer * renderer,

                               const SDL_FPoint * points, int count);

static int GL_RenderDrawLines(SDL_Renderer * renderer,

                              const SDL_FPoint * points, int count);

static int GL_RenderFillRects(SDL_Renderer * renderer,

                              const SDL_FRect * rects, int count);

static int GL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,

                         const SDL_Rect * srcrect, const SDL_FRect * dstrect);

static int GL_RenderCopyEx(SDL_Renderer * renderer, SDL_Texture * texture,

                         const SDL_Rect * srcrect, const SDL_FRect * dstrect,

                         const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip);

static int GL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,

                               Uint32 pixel_format, void * pixels, int pitch);

static void GL_RenderPresent(SDL_Renderer * renderer);

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

static void GL_DestroyRenderer(SDL_Renderer * renderer);

static int GL_BindTexture (SDL_Renderer * renderer, SDL_Texture *texture, float *texw, float *texh);

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

SDL_RenderDriver GL_RenderDriver = {

    GL_CreateRenderer,

    {

     "opengl",

     (SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE),

     1,

     {SDL_PIXELFORMAT_ARGB8888},

     0,

     0}

};

typedef struct GL_FBOList GL_FBOList;

struct GL_FBOList

{

    Uint32 w, h;

    GLuint FBO;

    GL_FBOList *next;

};

typedef struct

{

    SDL_GLContext context;

    SDL_bool GL_ARB_debug_output_supported;

    int errors;

    char **error_messages;

    GLDEBUGPROCARB next_error_callback;

    GLvoid *next_error_userparam;

    SDL_bool GL_ARB_texture_rectangle_supported;

    struct {

        GL_Shader shader;

        Uint32 color;

        int blendMode;

    } current;

    SDL_bool GL_EXT_framebuffer_object_supported;

    GL_FBOList *framebuffers;

    /* OpenGL functions */

#define SDL_PROC(ret,func,params) ret (APIENTRY *func) params;

#include "SDL_glfuncs.h"

#undef SDL_PROC

    /* Multitexture support */

    SDL_bool GL_ARB_multitexture_supported;

    PFNGLACTIVETEXTUREARBPROC glActiveTextureARB;

    GLint num_texture_units;

    PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT;

    PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT;

    PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT;

    PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT;

    PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT;

    /* Shader support */

    GL_ShaderContext *shaders;

} GL_RenderData;

typedef struct

{

    GLuint texture;

    GLenum type;

    GLfloat texw;

    GLfloat texh;

    GLenum format;

    GLenum formattype;

    void *pixels;

    int pitch;

    SDL_Rect locked_rect;

    /* YV12 texture support */

    SDL_bool yuv;

    GLuint utexture;

    GLuint vtexture;

    GL_FBOList *fbo;

} GL_TextureData;

SDL_FORCE_INLINE const char*

GL_TranslateError (GLenum error)

{

#define GL_ERROR_TRANSLATE(e) case e: return #e;

    switch (error) {

    GL_ERROR_TRANSLATE(GL_INVALID_ENUM)

    GL_ERROR_TRANSLATE(GL_INVALID_VALUE)

    GL_ERROR_TRANSLATE(GL_INVALID_OPERATION)

    GL_ERROR_TRANSLATE(GL_OUT_OF_MEMORY)

    GL_ERROR_TRANSLATE(GL_NO_ERROR)

    GL_ERROR_TRANSLATE(GL_STACK_OVERFLOW)

    GL_ERROR_TRANSLATE(GL_STACK_UNDERFLOW)

    GL_ERROR_TRANSLATE(GL_TABLE_TOO_LARGE)

    default:

        return "UNKNOWN";

}

#undef GL_ERROR_TRANSLATE

}

SDL_FORCE_INLINE void

GL_ClearErrors(SDL_Renderer *renderer)

{

    GL_RenderData *data = (GL_RenderData *) renderer->driverdata;

    if (data->GL_ARB_debug_output_supported) {

        if (data->errors) {

            int i;

            for (i = 0; i < data->errors; ++i) {

                SDL_free(data->error_messages[i]);

            }

            SDL_free(data->error_messages);

            data->errors = 0;

            data->error_messages = NULL;

        }

    } else {

        while (data->glGetError() != GL_NO_ERROR) {

            continue;

        }

    }

}

SDL_FORCE_INLINE int

GL_CheckAllErrors (const char *prefix, SDL_Renderer *renderer, const char *file, int line, const char *function)

{

    GL_RenderData *data = (GL_RenderData *) renderer->driverdata;

    int ret = 0;

    if (data->GL_ARB_debug_output_supported) {

        if (data->errors) {

            int i;

            for (i = 0; i < data->errors; ++i) {

                SDL_SetError("%s: %s (%d): %s %s", prefix, file, line, function, data->error_messages[i]);

                ret = -1;

            }

            GL_ClearErrors(renderer);

        }

    } else {

        /* check gl errors (can return multiple errors) */

        for (;;) {

            GLenum error = data->glGetError();

            if (error != GL_NO_ERROR) {

                if (prefix == NULL || prefix[0] == '\0') {

                    prefix = "generic";

                }

                SDL_SetError("%s: %s (%d): %s %s (0x%X)", prefix, file, line, function, GL_TranslateError(error), error);

                ret = -1;

            } else {

                break;

            }

        }

    }

    return ret;

}

#if 0

#define GL_CheckError(prefix, renderer)

#elif defined(_MSC_VER)

#define GL_CheckError(prefix, renderer) GL_CheckAllErrors(prefix, renderer, __FILE__, __LINE__, __FUNCTION__)

#else

#define GL_CheckError(prefix, renderer) GL_CheckAllErrors(prefix, renderer, __FILE__, __LINE__, __PRETTY_FUNCTION__)

#endif

static int

GL_LoadFunctions(GL_RenderData * data)

{

#ifdef __SDL_NOGETPROCADDR__

#define SDL_PROC(ret,func,params) data->func=func;

#else

#define SDL_PROC(ret,func,params) \

    do { \

        data->func = SDL_GL_GetProcAddress(#func); \

        if ( ! data->func ) { \

            return SDL_SetError("Couldn't load GL function %s: %s\n", #func, SDL_GetError()); \

        } \

    } while ( 0 );

#endif /* __SDL_NOGETPROCADDR__ */

#include "SDL_glfuncs.h"

#undef SDL_PROC

    return 0;

}

static SDL_GLContext SDL_CurrentContext = NULL;

static int

GL_ActivateRenderer(SDL_Renderer * renderer)

{

    GL_RenderData *data = (GL_RenderData *) renderer->driverdata;

    GL_ClearErrors(renderer);

    if (SDL_CurrentContext != data->context) {

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

            return -1;

        }

        SDL_CurrentContext = data->context;

        GL_UpdateViewport(renderer);

    }

    return 0;

}

/* This is called if we need to invalidate all of the SDL OpenGL state */

static void

GL_ResetState(SDL_Renderer *renderer)

{

    GL_RenderData *data = (GL_RenderData *) renderer->driverdata;

    if (SDL_CurrentContext == data->context) {

        GL_UpdateViewport(renderer);

    } else {

        GL_ActivateRenderer(renderer);

    }

    data->current.shader = SHADER_NONE;

    data->current.color = 0;

    data->current.blendMode = -1;

    data->glDisable(GL_DEPTH_TEST);

    data->glDisable(GL_CULL_FACE);

    /* This ended up causing video discrepancies between OpenGL and Direct3D */

    /*data->glEnable(GL_LINE_SMOOTH);*/

    data->glMatrixMode(GL_MODELVIEW);

    data->glLoadIdentity();

    GL_CheckError("", renderer);

}

GL_HandleDebugMessage(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const char *message, void *userParam)

{

    SDL_Renderer *renderer = (SDL_Renderer *) userParam;

    GL_RenderData *data = (GL_RenderData *) renderer->driverdata;

    if (type == GL_DEBUG_TYPE_ERROR_ARB) {

        /* Record this error */

        ++data->errors;

        data->error_messages = SDL_realloc(data->error_messages, data->errors * sizeof(*data->error_messages));

        if (data->error_messages) {

            data->error_messages[data->errors-1] = SDL_strdup(message);

        }

    }

    /* If there's another error callback, pass it along, otherwise log it */

    if (data->next_error_callback) {

        data->next_error_callback(source, type, id, severity, length, message, data->next_error_userparam);

    } else {

        if (type == GL_DEBUG_TYPE_ERROR_ARB) {

            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "%s", message);

        } else {

            SDL_LogDebug(SDL_LOG_CATEGORY_RENDER, "%s", message);

        }

    }

}

static GL_FBOList *

GL_GetFBO(GL_RenderData *data, Uint32 w, Uint32 h)

{

    GL_FBOList *result = data->framebuffers;

    while (result && ((result->w != w) || (result->h != h))) {

        result = result->next;

    }

    if (!result) {

        result = SDL_malloc(sizeof(GL_FBOList));

        if (result) {

            result->w = w;

            result->h = h;

            data->glGenFramebuffersEXT(1, &result->FBO);

            result->next = data->framebuffers;

            data->framebuffers = result;

        }

    }

    return result;

}

SDL_Renderer *

GL_CreateRenderer(SDL_Window * window, Uint32 flags)

{

    SDL_Renderer *renderer;

    GL_RenderData *data;

    const char *hint;

    GLint value;

    Uint32 window_flags;

    window_flags = SDL_GetWindowFlags(window);

    if (!(window_flags & SDL_WINDOW_OPENGL)) {

        if (SDL_RecreateWindow(window, window_flags | SDL_WINDOW_OPENGL) < 0) {

            /* Uh oh, better try to put it back... */

            SDL_RecreateWindow(window, window_flags);

            return NULL;

        }

    }

    renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));

    if (!renderer) {

        SDL_OutOfMemory();

        return NULL;

    }

    data = (GL_RenderData *) SDL_calloc(1, sizeof(*data));

    if (!data) {

        GL_DestroyRenderer(renderer);

        SDL_OutOfMemory();

        return NULL;

    }

    renderer->WindowEvent = GL_WindowEvent;

    renderer->CreateTexture = GL_CreateTexture;

    renderer->UpdateTexture = GL_UpdateTexture;

    renderer->LockTexture = GL_LockTexture;

    renderer->UnlockTexture = GL_UnlockTexture;

    renderer->SetRenderTarget = GL_SetRenderTarget;

    renderer->UpdateViewport = GL_UpdateViewport;

    renderer->UpdateClipRect = GL_UpdateClipRect;

    renderer->RenderClear = GL_RenderClear;

    renderer->RenderDrawPoints = GL_RenderDrawPoints;

    renderer->RenderDrawLines = GL_RenderDrawLines;

    renderer->RenderFillRects = GL_RenderFillRects;

    renderer->RenderCopy = GL_RenderCopy;

    renderer->RenderCopyEx = GL_RenderCopyEx;

    renderer->RenderReadPixels = GL_RenderReadPixels;

    renderer->RenderPresent = GL_RenderPresent;

    renderer->DestroyTexture = GL_DestroyTexture;

    renderer->DestroyRenderer = GL_DestroyRenderer;

    renderer->GL_BindTexture = GL_BindTexture;

    renderer->GL_UnbindTexture = GL_UnbindTexture;

    renderer->info = GL_RenderDriver.info;

    renderer->info.flags = SDL_RENDERER_ACCELERATED;

    renderer->driverdata = data;

    renderer->window = window;

    data->context = SDL_GL_CreateContext(window);

    if (!data->context) {

        GL_DestroyRenderer(renderer);

        return NULL;

    }

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

        GL_DestroyRenderer(renderer);

        return NULL;

    }

    if (GL_LoadFunctions(data) < 0) {

        GL_DestroyRenderer(renderer);

        return NULL;

    }

#ifdef __MACOSX__

    /* Enable multi-threaded rendering */

    /* Disabled until Ryan finishes his VBO/PBO code...

       CGLEnable(CGLGetCurrentContext(), kCGLCEMPEngine);

     */

#endif

    if (flags & SDL_RENDERER_PRESENTVSYNC) {

        SDL_GL_SetSwapInterval(1);

    } else {

        SDL_GL_SetSwapInterval(0);

    }

    if (SDL_GL_GetSwapInterval() > 0) {

        renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;

    }

    /* Check for debug output support */

    if (SDL_GL_ExtensionSupported("GL_ARB_debug_output")) {

        PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARBFunc = (PFNGLDEBUGMESSAGECALLBACKARBPROC) SDL_GL_GetProcAddress("glDebugMessageCallbackARB");

        data->GL_ARB_debug_output_supported = SDL_TRUE;

        data->glGetPointerv(GL_DEBUG_CALLBACK_FUNCTION_ARB, (GLvoid **)&data->next_error_callback);

        data->glGetPointerv(GL_DEBUG_CALLBACK_USER_PARAM_ARB, &data->next_error_userparam);

        glDebugMessageCallbackARBFunc(GL_HandleDebugMessage, renderer);

    }

    if (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle")

        || SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle")) {

        data->GL_ARB_texture_rectangle_supported = SDL_TRUE;

        data->glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, &value);

        renderer->info.max_texture_width = value;

        renderer->info.max_texture_height = value;

    } else {

        data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);

        renderer->info.max_texture_width = value;

        renderer->info.max_texture_height = value;

    }

    /* Check for multitexture support */

    if (SDL_GL_ExtensionSupported("GL_ARB_multitexture")) {

        data->glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) SDL_GL_GetProcAddress("glActiveTextureARB");

        if (data->glActiveTextureARB) {

            data->GL_ARB_multitexture_supported = SDL_TRUE;

            data->glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &data->num_texture_units);

        }

    }

    /* Check for shader support */

    hint = SDL_GetHint(SDL_HINT_RENDER_OPENGL_SHADERS);

    if (!hint || *hint != '0') {

        data->shaders = GL_CreateShaderContext();

    }

    SDL_LogInfo(SDL_LOG_CATEGORY_RENDER, "OpenGL shaders: %s",

                data->shaders ? "ENABLED" : "DISABLED");

    /* We support YV12 textures using 3 textures and a shader */

    if (data->shaders && data->num_texture_units >= 3) {

        renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_YV12;

        renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_IYUV;

    }

    if (SDL_GL_ExtensionSupported("GL_EXT_framebuffer_object")) {