/*

  Simple DirectMedia Layer

  Copyright (C) 1997-2012 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"

/* The SDL 2D rendering system */

#include "SDL_hints.h"

#include "SDL_log.h"

#include "SDL_render.h"

#include "SDL_sysrender.h"

#include "software/SDL_render_sw_c.h"

#define SDL_WINDOWRENDERDATA    "_SDL_WindowRenderData"

#define CHECK_RENDERER_MAGIC(renderer, retval) \

    if (!renderer || renderer->magic != &renderer_magic) { \

        SDL_SetError("Invalid renderer"); \

        return retval; \

    }

#define CHECK_TEXTURE_MAGIC(texture, retval) \

    if (!texture || texture->magic != &texture_magic) { \

        SDL_SetError("Invalid texture"); \

        return retval; \

    }

static const SDL_RenderDriver *render_drivers[] = {

#if !SDL_RENDER_DISABLED

#if SDL_VIDEO_RENDER_D3D

    &D3D_RenderDriver,

#endif

#if SDL_VIDEO_RENDER_OGL

    &GL_RenderDriver,

#endif

#if SDL_VIDEO_RENDER_OGL_ES2

    &GLES2_RenderDriver,

#endif

#if SDL_VIDEO_RENDER_OGL_ES

    &GLES_RenderDriver,

#endif

#if SDL_VIDEO_RENDER_DIRECTFB

    &DirectFB_RenderDriver,

#endif

#if SDL_VIDEO_RENDER_NDS

    &NDS_RenderDriver,

#endif

    &SW_RenderDriver

#endif /* !SDL_RENDER_DISABLED */

};

static char renderer_magic;

static char texture_magic;

static int UpdateLogicalSize(SDL_Renderer *renderer);

int

SDL_GetNumRenderDrivers(void)

{

    return SDL_arraysize(render_drivers);

}

int

SDL_GetRenderDriverInfo(int index, SDL_RendererInfo * info)

{

    if (index < 0 || index >= SDL_GetNumRenderDrivers()) {

        SDL_SetError("index must be in the range of 0 - %d",

                     SDL_GetNumRenderDrivers() - 1);

        return -1;

    }

    *info = render_drivers[index]->info;

    return 0;

}

static int

SDL_RendererEventWatch(void *userdata, SDL_Event *event)

{

    SDL_Renderer *renderer = (SDL_Renderer *)userdata;

    if (event->type == SDL_WINDOWEVENT) {

        SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);

        if (window == renderer->window) {

            if (renderer->WindowEvent) {

                renderer->WindowEvent(renderer, &event->window);

            }

            if (event->window.event == SDL_WINDOWEVENT_RESIZED) {

                if (renderer->logical_w) {

                    /* We'll update the renderer in the SIZE_CHANGED event */

                } else {

                    /* Try to keep the previous viewport centered */

                    int w, h;

                    SDL_GetWindowSize(window, &w, &h);

                    if (renderer->target) {

                        renderer->viewport_backup.x = (w - renderer->viewport_backup.w) / 2;

                        renderer->viewport_backup.y = (h - renderer->viewport_backup.h) / 2;

                    } else {

                        renderer->viewport.x = (w - renderer->viewport.w) / 2;

                        renderer->viewport.y = (h - renderer->viewport.h) / 2;

                        renderer->UpdateViewport(renderer);

                    }

                }

                renderer->resized = SDL_TRUE;

            } else if (event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {

                if (renderer->logical_w) {

                    UpdateLogicalSize(renderer);

                } else if (!renderer->resized) {

                    /* Window was programmatically resized, reset viewport */

                    int w, h;

                    SDL_GetWindowSize(window, &w, &h);

                    if (renderer->target) {

                        renderer->viewport_backup.x = 0;

                        renderer->viewport_backup.y = 0;

                        renderer->viewport_backup.w = w;

                        renderer->viewport_backup.h = h;

                    } else {

                        renderer->viewport.x = 0;

                        renderer->viewport.y = 0;

                        renderer->viewport.w = w;

                        renderer->viewport.h = h;

                        renderer->UpdateViewport(renderer);

                    }

                }

                renderer->resized = SDL_FALSE;

            } else if (event->window.event == SDL_WINDOWEVENT_HIDDEN) {

                renderer->hidden = SDL_TRUE;

            } else if (event->window.event == SDL_WINDOWEVENT_SHOWN) {

                if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)) {

                    renderer->hidden = SDL_FALSE;

                }

            } else if (event->window.event == SDL_WINDOWEVENT_MINIMIZED) {

                renderer->hidden = SDL_TRUE;

            } else if (event->window.event == SDL_WINDOWEVENT_RESTORED) {

                if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_HIDDEN)) {

                    renderer->hidden = SDL_FALSE;

                }

            }

        }

    } else if (event->type == SDL_MOUSEMOTION) {

        if (renderer->logical_w) {

            event->motion.x -= renderer->viewport.x;

            event->motion.y -= renderer->viewport.y;

            event->motion.x = (int)(event->motion.x / renderer->scale.x);

            event->motion.y = (int)(event->motion.y / renderer->scale.y);

        }

    } else if (event->type == SDL_MOUSEBUTTONDOWN ||

               event->type == SDL_MOUSEBUTTONUP) {

        if (renderer->logical_w) {

            event->button.x -= renderer->viewport.x;

            event->button.y -= renderer->viewport.y;

            event->button.x = (int)(event->button.x / renderer->scale.x);

            event->button.y = (int)(event->button.y / renderer->scale.y);

        }

    }

    return 0;

}

int

SDL_CreateWindowAndRenderer(int width, int height, Uint32 window_flags,

                            SDL_Window **window, SDL_Renderer **renderer)

{

    *window = SDL_CreateWindow(NULL, SDL_WINDOWPOS_UNDEFINED,

                                     SDL_WINDOWPOS_UNDEFINED,

                                     width, height, window_flags);

    if (!*window) {

        *renderer = NULL;

        return -1;

    }

    *renderer = SDL_CreateRenderer(*window, -1, 0);

    if (!*renderer) {

        return -1;

    }

    return 0;

}

SDL_Renderer *

SDL_CreateRenderer(SDL_Window * window, int index, Uint32 flags)

{

    SDL_Renderer *renderer = NULL;

    int n = SDL_GetNumRenderDrivers();

    const char *hint;

    if (!window) {

        SDL_SetError("Invalid window");

        return NULL;

    }

    if (SDL_GetRenderer(window)) {

        SDL_SetError("Renderer already associated with window");

        return NULL;

    }

    hint = SDL_GetHint(SDL_HINT_RENDER_VSYNC);

    if (hint) {

        if (*hint == '0') {

            flags &= ~SDL_RENDERER_PRESENTVSYNC;

        } else {

            flags |= SDL_RENDERER_PRESENTVSYNC;

        }

    }

    if (index < 0) {

        hint = SDL_GetHint(SDL_HINT_RENDER_DRIVER);

        if (hint) {

            for (index = 0; index < n; ++index) {

                const SDL_RenderDriver *driver = render_drivers[index];

                if (SDL_strcasecmp(hint, driver->info.name) == 0) {

                    /* Create a new renderer instance */

                    renderer = driver->CreateRenderer(window, flags);

                    break;

                }

            }

        }

        if (!renderer) {

            for (index = 0; index < n; ++index) {

                const SDL_RenderDriver *driver = render_drivers[index];

                if ((driver->info.flags & flags) == flags) {

                    /* Create a new renderer instance */

                    renderer = driver->CreateRenderer(window, flags);

                    if (renderer) {

                        /* Yay, we got one! */

                        break;

                    }

                }

            }

        }

        if (index == n) {

            SDL_SetError("Couldn't find matching render driver");

            return NULL;

        }

    } else {

        if (index >= SDL_GetNumRenderDrivers()) {

            SDL_SetError("index must be -1 or in the range of 0 - %d",

                         SDL_GetNumRenderDrivers() - 1);

            return NULL;

        }

        /* Create a new renderer instance */

        renderer = render_drivers[index]->CreateRenderer(window, flags);

    }

    if (renderer) {

        renderer->magic = &renderer_magic;

        renderer->window = window;

        renderer->scale.x = 1.0f;

        renderer->scale.y = 1.0f;

        if (SDL_GetWindowFlags(window) & (SDL_WINDOW_HIDDEN|SDL_WINDOW_MINIMIZED)) {

            renderer->hidden = SDL_TRUE;

        } else {

            renderer->hidden = SDL_FALSE;

        }

        SDL_SetWindowData(window, SDL_WINDOWRENDERDATA, renderer);

        SDL_RenderSetViewport(renderer, NULL);

        SDL_AddEventWatch(SDL_RendererEventWatch, renderer);

        SDL_LogInfo(SDL_LOG_CATEGORY_RENDER,

                    "Created renderer: %s", renderer->info.name);

    }

    return renderer;

}

SDL_Renderer *

SDL_CreateSoftwareRenderer(SDL_Surface * surface)

{

#if !SDL_RENDER_DISABLED

    SDL_Renderer *renderer;

    renderer = SW_CreateRendererForSurface(surface);

    if (renderer) {

        renderer->magic = &renderer_magic;

        SDL_RenderSetViewport(renderer, NULL);

    }

    return renderer;

#else

    SDL_SetError("SDL not built with rendering support");

    return NULL;

#endif /* !SDL_RENDER_DISABLED */

}

SDL_Renderer *

SDL_GetRenderer(SDL_Window * window)

{

    return (SDL_Renderer *)SDL_GetWindowData(window, SDL_WINDOWRENDERDATA);

}

int

SDL_GetRendererInfo(SDL_Renderer * renderer, SDL_RendererInfo * info)

{

    CHECK_RENDERER_MAGIC(renderer, -1);

    *info = renderer->info;

    return 0;

}

static SDL_bool

IsSupportedFormat(SDL_Renderer * renderer, Uint32 format)

{

    Uint32 i;

    for (i = 0; i < renderer->info.num_texture_formats; ++i) {

        if (renderer->info.texture_formats[i] == format) {

            return SDL_TRUE;

        }

    }

    return SDL_FALSE;

}

static Uint32

GetClosestSupportedFormat(SDL_Renderer * renderer, Uint32 format)

{

    Uint32 i;

    if (SDL_ISPIXELFORMAT_FOURCC(format)) {

        /* Look for an exact match */

        for (i = 0; i < renderer->info.num_texture_formats; ++i) {

            if (renderer->info.texture_formats[i] == format) {

                return renderer->info.texture_formats[i];

            }

        }

    } else {

        SDL_bool hasAlpha = SDL_ISPIXELFORMAT_ALPHA(format);

        /* We just want to match the first format that has the same channels */

        for (i = 0; i < renderer->info.num_texture_formats; ++i) {

            if (!SDL_ISPIXELFORMAT_FOURCC(renderer->info.texture_formats[i]) &&

                SDL_ISPIXELFORMAT_ALPHA(renderer->info.texture_formats[i]) == hasAlpha) {

                return renderer->info.texture_formats[i];

            }

        }

    }

    return renderer->info.texture_formats[0];

}

SDL_Texture *

SDL_CreateTexture(SDL_Renderer * renderer, Uint32 format, int access, int w, int h)

{

    SDL_Texture *texture;

    CHECK_RENDERER_MAGIC(renderer, NULL);

    if (!format) {

        format = renderer->info.texture_formats[0];

    }

    if (SDL_ISPIXELFORMAT_INDEXED(format)) {

        SDL_SetError("Palettized textures are not supported");

        return NULL;

    }

    if (w <= 0 || h <= 0) {

        SDL_SetError("Texture dimensions can't be 0");

        return NULL;

    }

    texture = (SDL_Texture *) SDL_calloc(1, sizeof(*texture));

    if (!texture) {

        SDL_OutOfMemory();

        return NULL;

    }

    texture->magic = &texture_magic;

    texture->format = format;

    texture->access = access;

    texture->w = w;

    texture->h = h;

    texture->r = 255;

    texture->g = 255;

    texture->b = 255;

    texture->a = 255;

    texture->renderer = renderer;

    texture->next = renderer->textures;

    if (renderer->textures) {

        renderer->textures->prev = texture;

    }

    renderer->textures = texture;

    if (IsSupportedFormat(renderer, format)) {

        if (renderer->CreateTexture(renderer, texture) < 0) {

            SDL_DestroyTexture(texture);

            return 0;

        }

    } else {

        texture->native = SDL_CreateTexture(renderer,

                                GetClosestSupportedFormat(renderer, format),

                                access, w, h);

        if (!texture->native) {

            SDL_DestroyTexture(texture);

            return NULL;

        }

        /* Swap textures to have texture before texture->native in the list */

        texture->native->next = texture->next;

        texture->prev = texture->native->prev;

        texture->native->prev = texture;

        texture->next = texture->native;

        renderer->textures = texture;

        if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {

            texture->yuv = SDL_SW_CreateYUVTexture(format, w, h);

            if (!texture->yuv) {

                SDL_DestroyTexture(texture);

                return NULL;

            }

        } else if (access == SDL_TEXTUREACCESS_STREAMING) {

            /* The pitch is 4 byte aligned */

            texture->pitch = (((w * SDL_BYTESPERPIXEL(format)) + 3) & ~3);

            texture->pixels = SDL_calloc(1, texture->pitch * h);

            if (!texture->pixels) {

                SDL_DestroyTexture(texture);

                return NULL;

            }

        }

    }

    return texture;

}

SDL_Texture *

SDL_CreateTextureFromSurface(SDL_Renderer * renderer, SDL_Surface * surface)

{

    const SDL_PixelFormat *fmt;

    SDL_bool needAlpha;

    Uint32 i;

    Uint32 format;

    SDL_Texture *texture;

    CHECK_RENDERER_MAGIC(renderer, NULL);

    if (!surface) {

        SDL_SetError("SDL_CreateTextureFromSurface() passed NULL surface");

        return NULL;

    }

    /* See what the best texture format is */

    fmt = surface->format;

    if (fmt->Amask || SDL_GetColorKey(surface, NULL) == 0) {

        needAlpha = SDL_TRUE;

    } else {

        needAlpha = SDL_FALSE;

    }

    format = renderer->info.texture_formats[0];

    for (i = 0; i < renderer->info.num_texture_formats; ++i) {

        if (!SDL_ISPIXELFORMAT_FOURCC(renderer->info.texture_formats[i]) &&

            SDL_ISPIXELFORMAT_ALPHA(renderer->info.texture_formats[i]) == needAlpha) {

            format = renderer->info.texture_formats[i];

            break;

        }

    }

    texture = SDL_CreateTexture(renderer, format, SDL_TEXTUREACCESS_STATIC,

                                surface->w, surface->h);

    if (!texture) {

        return NULL;

    }

    if (format == surface->format->format) {

        if (SDL_MUSTLOCK(surface)) {

            SDL_LockSurface(surface);

            SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch);

            SDL_UnlockSurface(surface);

        } else {

            SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch);

        }

    } else {

        SDL_PixelFormat *dst_fmt;

        SDL_Surface *temp = NULL;

        /* Set up a destination surface for the texture update */

        dst_fmt = SDL_AllocFormat(format);

        temp = SDL_ConvertSurface(surface, dst_fmt, 0);

        SDL_FreeFormat(dst_fmt);

        if (temp) {