/*

    SDL - Simple DirectMedia Layer

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

/* The SDL 2D rendering system */

#include "SDL_hints.h"

#include "SDL_log.h"

#include "SDL_render.h"

#include "SDL_sysrender.h"

#include "../video/SDL_pixels_c.h"

#include "software/SDL_render_sw_c.h"

#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

    &SW_RenderDriver

#endif /* !SDL_RENDER_DISABLED */

};

static char renderer_magic;

static char texture_magic;

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 && renderer->WindowEvent) {

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

        if (window == renderer->window) {

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

        }

    }

    return 0;

}

SDL_Renderer *

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

{

    SDL_Renderer *renderer = NULL;

    int n = SDL_GetNumRenderDrivers();

    const char *hint;

    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;

        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

    return SW_CreateRendererForSurface(surface);

#else

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

    return NULL;

#endif /* !SDL_RENDER_DISABLED */

}

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_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 (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;

        }

        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_malloc(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;

    int bpp;

    Uint32 Rmask, Gmask, Bmask, Amask;

    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;

        }

    }

    if (!SDL_PixelFormatEnumToMasks(format, &bpp,

                                    &Rmask, &Gmask, &Bmask, &Amask)) {

        SDL_SetError("Unknown pixel format");

        return NULL;

    }

    texture = SDL_CreateTexture(renderer, format, SDL_TEXTUREACCESS_STATIC,

                                surface->w, surface->h);

    if (!texture) {

        return NULL;

    }

    if (bpp == fmt->BitsPerPixel && Rmask == fmt->Rmask && Gmask == fmt->Gmask

        && Bmask == fmt->Bmask && Amask == fmt->Amask) {

        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 */

        SDL_InitFormat(&dst_fmt, bpp, Rmask, Gmask, Bmask, Amask);

        temp = SDL_ConvertSurface(surface, &dst_fmt, 0);

        if (temp) {

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

            SDL_FreeSurface(temp);

        } else {

            SDL_DestroyTexture(texture);

            return NULL;

        }

    }

    {

        Uint8 r, g, b, a;

        SDL_BlendMode blendMode;

        SDL_GetSurfaceColorMod(surface, &r, &g, &b);

        SDL_SetTextureColorMod(texture, r, g, b);

        SDL_GetSurfaceAlphaMod(surface, &a);

        SDL_SetTextureAlphaMod(texture, a);

        if (SDL_GetColorKey(surface, NULL) == 0) {

            /* We converted to a texture with alpha format */

            SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);

        } else {

            SDL_GetSurfaceBlendMode(surface, &blendMode);

            SDL_SetTextureBlendMode(texture, blendMode);

        }

    }

    return texture;

}

int

SDL_QueryTexture(SDL_Texture * texture, Uint32 * format, int *access,

                 int *w, int *h)

{

    CHECK_TEXTURE_MAGIC(texture, -1);

    if (format) {

        *format = texture->format;

    }

    if (access) {

        *access = texture->access;

    }

    if (w) {

        *w = texture->w;

    }

    if (h) {

        *h = texture->h;

    }

    return 0;

}

int

SDL_SetTextureColorMod(SDL_Texture * texture, Uint8 r, Uint8 g, Uint8 b)

{

    SDL_Renderer *renderer;

    CHECK_TEXTURE_MAGIC(texture, -1);

    renderer = texture->renderer;

    if (r < 255 || g < 255 || b < 255) {

        texture->modMode |= SDL_TEXTUREMODULATE_COLOR;

    } else {

        texture->modMode &= ~SDL_TEXTUREMODULATE_COLOR;

    }

    texture->r = r;

    texture->g = g;

    texture->b = b;

    if (texture->native) {

        return SDL_SetTextureColorMod(texture->native, r, g, b);

    } else if (renderer->SetTextureColorMod) {

        return renderer->SetTextureColorMod(renderer, texture);

    } else {

        return 0;

    }

}

int

SDL_GetTextureColorMod(SDL_Texture * texture, Uint8 * r, Uint8 * g,

                       Uint8 * b)

{

    SDL_Renderer *renderer;

    CHECK_TEXTURE_MAGIC(texture, -1);

    renderer = texture->renderer;

    if (r) {

        *r = texture->r;

    }

    if (g) {

        *g = texture->g;

    }

    if (b) {

        *b = texture->b;

    }

    return 0;

}

int

SDL_SetTextureAlphaMod(SDL_Texture * texture, Uint8 alpha)

{

    SDL_Renderer *renderer;

    CHECK_TEXTURE_MAGIC(texture, -1);

    renderer = texture->renderer;

    if (alpha < 255) {

        texture->modMode |= SDL_TEXTUREMODULATE_ALPHA;

    } else {

        texture->modMode &= ~SDL_TEXTUREMODULATE_ALPHA;

    }

    texture->a = alpha;

    if (texture->native) {

        return SDL_SetTextureAlphaMod(texture->native, alpha);

    } else if (renderer->SetTextureAlphaMod) {

        return renderer->SetTextureAlphaMod(renderer, texture);

    } else {

        return 0;

    }

}

int

SDL_GetTextureAlphaMod(SDL_Texture * texture, Uint8 * alpha)

{

    CHECK_TEXTURE_MAGIC(texture, -1);

    if (alpha) {

        *alpha = texture->a;

    }

    return 0;

}

int

SDL_SetTextureBlendMode(SDL_Texture * texture, SDL_BlendMode blendMode)

{

    SDL_Renderer *renderer;

    CHECK_TEXTURE_MAGIC(texture, -1);

    renderer = texture->renderer;

    texture->blendMode = blendMode;

    if (texture->native) {

        return SDL_SetTextureBlendMode(texture->native, blendMode);

    } else if (renderer->SetTextureBlendMode) {

        return renderer->SetTextureBlendMode(renderer, texture);

    } else {

        return 0;

    }

}