/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2006 Sam Lantinga

    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_OPENGL

/* OpenGL renderer implementation */

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

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

static int GL_SetTexturePalette(SDL_Renderer * renderer,

                                SDL_Texture * texture,

                                const SDL_Color * colors, int firstcolor,

                                int ncolors);

static int GL_GetTexturePalette(SDL_Renderer * renderer,

                                SDL_Texture * texture, SDL_Color * colors,

                                int firstcolor, int ncolors);

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, int markDirty,

                          void **pixels, int *pitch);

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

static void GL_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture,

                            int numrects, const SDL_Rect * rects);

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

                         Uint32 color);

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

                         const SDL_Rect * srcrect, const SDL_Rect * dstrect,

                         int blendMode, int scaleMode);

static void GL_RenderPresent(SDL_Renderer * renderer);

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

static void GL_DestroyRenderer(SDL_Renderer * renderer);

SDL_RenderDriver GL_RenderDriver = {

    GL_CreateRenderer,

    {

     "opengl",

     (SDL_Renderer_PresentDiscard | SDL_Renderer_PresentVSync |

      SDL_Renderer_Accelerated),

     (SDL_TextureBlendMode_None | SDL_TextureBlendMode_Mask |

      SDL_TextureBlendMode_Blend | SDL_TextureBlendMode_Add |

      SDL_TextureBlendMode_Mod),

     (SDL_TextureScaleMode_None | SDL_TextureScaleMode_Fast |

      SDL_TextureScaleMode_Best),

     {

      SDL_PixelFormat_Index8,

      SDL_PixelFormat_RGB332,

      SDL_PixelFormat_RGB444,

      SDL_PixelFormat_RGB555,

      SDL_PixelFormat_ARGB4444,

      SDL_PixelFormat_ARGB1555,

      SDL_PixelFormat_RGB565,

      SDL_PixelFormat_RGB888,

      SDL_PixelFormat_ARGB8888,

     0,

     0}

};

typedef struct

{

    SDL_GLContext context;

} GL_RenderData;

typedef struct

{

    GLuint texture;

    GLfloat texw;

    GLfloat texh;

    void *pixels;

    int pitch;

} GL_TextureData;

void

GL_AddRenderDriver(_THIS)

{

        SDL_AddRenderDriver(0, &GL_RenderDriver);

    }

}

SDL_Renderer *

GL_CreateRenderer(SDL_Window * window, Uint32 flags)

{

    SDL_Renderer *renderer;

    GL_RenderData *data;

    if (!(window->flags & SDL_WINDOW_OPENGL)) {

        SDL_SetError

            ("The OpenGL renderer can only be used on OpenGL windows");

        return NULL;

    }

    if (!renderer) {

        SDL_OutOfMemory();

        return NULL;

    }

    if (!data) {

        GL_DestroyRenderer(renderer);

        SDL_OutOfMemory();

        return NULL;

    }

    renderer->CreateTexture = GL_CreateTexture;

    renderer->SetTexturePalette = GL_SetTexturePalette;

    renderer->GetTexturePalette = GL_GetTexturePalette;

    renderer->UpdateTexture = GL_UpdateTexture;

    renderer->LockTexture = GL_LockTexture;

    renderer->UnlockTexture = GL_UnlockTexture;

    renderer->DirtyTexture = GL_DirtyTexture;

    renderer->RenderFill = GL_RenderFill;

    renderer->RenderCopy = GL_RenderCopy;

    renderer->RenderPresent = GL_RenderPresent;

    renderer->DestroyTexture = GL_DestroyTexture;

    renderer->DestroyRenderer = GL_DestroyRenderer;

    renderer->info = GL_RenderDriver.info;

    renderer->window = window->id;

    renderer->driverdata = data;

    renderer->info.flags =

        (SDL_Renderer_PresentDiscard | SDL_Renderer_Accelerated);

    data->context = SDL_GL_CreateContext(window->id);

    if (!data->context) {

        GL_DestroyRenderer(renderer);

        return NULL;

    }

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

        GL_DestroyRenderer(renderer);

        return NULL;

    }

    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;

    }

    /* Set up parameters for rendering */

    glDisable(GL_DEPTH_TEST);

    glDisable(GL_CULL_FACE);

    glEnable(GL_TEXTURE_2D);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity();

    glViewport(0, 0, window->w, window->h);

    glOrtho(0.0, (GLdouble) window->w, (GLdouble) window->h, 0.0, 0.0, 1.0);

    return renderer;

}

static int

GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)

{

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

    SDL_Window *window = SDL_GetWindowFromID(renderer->window);

    GL_TextureData *data;

    if (!data) {

        SDL_OutOfMemory();

        return -1;

    }

    texture->driverdata = data;

    return 0;

}

static int

GL_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,

                     const SDL_Color * colors, int firstcolor, int ncolors)

{

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

    GL_TextureData *data = (GL_TextureData *) texture->driverdata;

    return 0;

}

static int

GL_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,

                     SDL_Color * colors, int firstcolor, int ncolors)

{

    GL_TextureData *data = (GL_TextureData *) texture->driverdata;

    return 0;

}

static int

GL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,

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

{

    GL_TextureData *data = (GL_TextureData *) texture->driverdata;

    return 0;

}

static int

GL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,

               const SDL_Rect * rect, int markDirty, void **pixels,

               int *pitch)

{

    GL_TextureData *data = (GL_TextureData *) texture->driverdata;

    }

    return 0;

}

static void

GL_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)

{

}

static void

GL_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, int numrects,

                const SDL_Rect * rects)

{

    GL_TextureData *data = (GL_TextureData *) texture->driverdata;

    int i;

    for (i = 0; i < numrects; ++i) {

    }

}

static int

GL_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect, Uint32 color)

{

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

    SDL_Window *window = SDL_GetWindowFromID(renderer->window);

    GLclampf r, g, b, a;

    a = ((GLclampf) ((color >> 24) & 0xFF)) / 255.0f;

    r = ((GLclampf) ((color >> 16) & 0xFF)) / 255.0f;

    g = ((GLclampf) ((color >> 8) & 0xFF)) / 255.0f;

    b = ((GLclampf) (color & 0xFF)) / 255.0f;

    glClearColor(r, g, b, a);

    glViewport(rect->x, window->h - rect->y, rect->w, rect->h);

    glClear(GL_COLOR_BUFFER_BIT);

    glViewport(0, 0, window->w, window->h);

    return 0;

}

static int

GL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,

              const SDL_Rect * srcrect, const SDL_Rect * dstrect,

              int blendMode, int scaleMode)

{

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

    GL_TextureData *texturedata = (GL_TextureData *) texture->driverdata;

    int minx, miny, maxx, maxy;

    GLfloat minu, maxu, minv, maxv;

    minx = dstrect->x;

    miny = dstrect->y;

    maxx = dstrect->x + dstrect->w;

    maxy = dstrect->y + dstrect->h;

    minu = (GLfloat) srcrect->x / texture->w;

    maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w;

    minv = (GLfloat) srcrect->y / texture->h;

    maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h;

    switch (blendMode) {

    case SDL_TextureBlendMode_None:

        glDisable(GL_BLEND);

        break;

    case SDL_TextureBlendMode_Mask:

    case SDL_TextureBlendMode_Blend:

        glEnable(GL_BLEND);

        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        break;

    case SDL_TextureBlendMode_Add:

        glEnable(GL_BLEND);

        glBlendFunc(GL_SRC_ALPHA, GL_ONE);

        break;

    case SDL_TextureBlendMode_Mod:

        glEnable(GL_BLEND);

        glBlendFunc(GL_ZERO, GL_SRC_COLOR);

        break;

    }

    switch (scaleMode) {

    case SDL_TextureScaleMode_None:

    case SDL_TextureScaleMode_Fast:

        break;

    case SDL_TextureScaleMode_Slow:

    case SDL_TextureScaleMode_Best:

        break;

    }

    glBegin(GL_TRIANGLE_STRIP);

    glTexCoord2f(minu, minv);