summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/SDL2/src/render/SDL_render.c
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/SDL2/src/render/SDL_render.c')
-rw-r--r--3rdparty/SDL2/src/render/SDL_render.c1973
1 files changed, 0 insertions, 1973 deletions
diff --git a/3rdparty/SDL2/src/render/SDL_render.c b/3rdparty/SDL2/src/render/SDL_render.c
deleted file mode 100644
index 94750810d8b..00000000000
--- a/3rdparty/SDL2/src/render/SDL_render.c
+++ /dev/null
@@ -1,1973 +0,0 @@
-/*
- Simple DirectMedia Layer
- Copyright (C) 1997-2016 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_internal.h"
-
-/* The SDL 2D rendering system */
-
-#include "SDL_assert.h"
-#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; \
- }
-
-
-#if !SDL_RENDER_DISABLED
-static const SDL_RenderDriver *render_drivers[] = {
-#if SDL_VIDEO_RENDER_D3D
- &D3D_RenderDriver,
-#endif
-#if SDL_VIDEO_RENDER_D3D11
- &D3D11_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_PSP
- &PSP_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)
-{
-#if !SDL_RENDER_DISABLED
- return SDL_arraysize(render_drivers);
-#else
- return 0;
-#endif
-}
-
-int
-SDL_GetRenderDriverInfo(int index, SDL_RendererInfo * info)
-{
-#if !SDL_RENDER_DISABLED
- if (index < 0 || index >= SDL_GetNumRenderDrivers()) {
- return SDL_SetError("index must be in the range of 0 - %d",
- SDL_GetNumRenderDrivers() - 1);
- }
- *info = render_drivers[index]->info;
- return 0;
-#else
- return SDL_SetError("SDL not built with rendering support");
-#endif
-}
-
-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_SIZE_CHANGED) {
- /* Make sure we're operating on the default render target */
- SDL_Texture *saved_target = SDL_GetRenderTarget(renderer);
- if (saved_target) {
- SDL_SetRenderTarget(renderer, NULL);
- }
-
- if (renderer->logical_w) {
- UpdateLogicalSize(renderer);
- } else {
- /* Window was resized, reset viewport */
- int w, h;
-
- if (renderer->GetOutputSize) {
- renderer->GetOutputSize(renderer, &w, &h);
- } else {
- SDL_GetWindowSize(renderer->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);
- }
- }
-
- if (saved_target) {
- SDL_SetRenderTarget(renderer, saved_target);
- }
- } 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 ||
- event->window.event == SDL_WINDOWEVENT_MAXIMIZED) {
- if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_HIDDEN)) {
- renderer->hidden = SDL_FALSE;
- }
- }
- }
- } else if (event->type == SDL_MOUSEMOTION) {
- SDL_Window *window = SDL_GetWindowFromID(event->motion.windowID);
- if (renderer->logical_w && window == renderer->window) {
- 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);
- if (event->motion.xrel > 0) {
- event->motion.xrel = SDL_max(1, (int)(event->motion.xrel / renderer->scale.x));
- } else if (event->motion.xrel < 0) {
- event->motion.xrel = SDL_min(-1, (int)(event->motion.xrel / renderer->scale.x));
- }
- if (event->motion.yrel > 0) {
- event->motion.yrel = SDL_max(1, (int)(event->motion.yrel / renderer->scale.y));
- } else if (event->motion.yrel < 0) {
- event->motion.yrel = SDL_min(-1, (int)(event->motion.yrel / renderer->scale.y));
- }
- }
- } else if (event->type == SDL_MOUSEBUTTONDOWN ||
- event->type == SDL_MOUSEBUTTONUP) {
- SDL_Window *window = SDL_GetWindowFromID(event->button.windowID);
- if (renderer->logical_w && window == renderer->window) {
- 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)
-{
-#if !SDL_RENDER_DISABLED
- 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;
- }
-
- if (SDL_GetHint(SDL_HINT_RENDER_VSYNC)) {
- if (SDL_GetHintBoolean(SDL_HINT_RENDER_VSYNC, SDL_TRUE)) {
- 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;
-#else
- SDL_SetError("SDL not built with rendering support");
- return NULL;
-#endif
-}
-
-SDL_Renderer *
-SDL_CreateSoftwareRenderer(SDL_Surface * surface)
-{
-#if !SDL_RENDER_DISABLED
- SDL_Renderer *renderer;
-
- renderer = SW_CreateRendererForSurface(surface);
-
- if (renderer) {
- renderer->magic = &renderer_magic;
- renderer->scale.x = 1.0f;
- renderer->scale.y = 1.0f;
-
- 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;
-}
-
-int
-SDL_GetRendererOutputSize(SDL_Renderer * renderer, int *w, int *h)
-{
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- if (renderer->target) {
- return SDL_QueryTexture(renderer->target, NULL, NULL, w, h);
- } else if (renderer->GetOutputSize) {
- return renderer->GetOutputSize(renderer, w, h);
- } else if (renderer->window) {
- SDL_GetWindowSize(renderer->window, w, h);
- return 0;
- } else {
- SDL_assert(0 && "This should never happen");
- return SDL_SetError("Renderer doesn't support querying output size");
- }
-}
-
-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_BYTESPERPIXEL(format) == 0) {
- SDL_SetError("Invalid texture format");
- return 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;
- }
- if ((renderer->info.max_texture_width && w > renderer->info.max_texture_width) ||
- (renderer->info.max_texture_height && h > renderer->info.max_texture_height)) {
- SDL_SetError("Texture dimensions are limited to %dx%d", renderer->info.max_texture_width, renderer->info.max_texture_height);
- 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 NULL;
- }
- } 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;
- if (texture->native->next) {
- texture->native->next->prev = texture->native;
- }
- texture->prev = texture->native->prev;
- if (texture->prev) {
- texture->prev->next = texture;
- }
- 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);
- if (!dst_fmt) {
- SDL_DestroyTexture(texture);
- return NULL;
- }
- temp = SDL_ConvertSurface(surface, dst_fmt, 0);
- SDL_FreeFormat(dst_fmt);
- 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)
-{
- CHECK_TEXTURE_MAGIC(texture, -1);
-
- 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;
- }
-}
-
-int
-SDL_GetTextureBlendMode(SDL_Texture * texture, SDL_BlendMode *blendMode)
-{
- CHECK_TEXTURE_MAGIC(texture, -1);
-
- if (blendMode) {
- *blendMode = texture->blendMode;
- }
- return 0;
-}
-
-static int
-SDL_UpdateTextureYUV(SDL_Texture * texture, const SDL_Rect * rect,
- const void *pixels, int pitch)
-{
- SDL_Texture *native = texture->native;
- SDL_Rect full_rect;
-
- if (SDL_SW_UpdateYUVTexture(texture->yuv, rect, pixels, pitch) < 0) {
- return -1;
- }
-
- full_rect.x = 0;
- full_rect.y = 0;
- full_rect.w = texture->w;
- full_rect.h = texture->h;
- rect = &full_rect;
-
- if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
- /* We can lock the texture and copy to it */
- void *native_pixels;
- int native_pitch;
-
- if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
- return -1;
- }
- SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
- rect->w, rect->h, native_pixels, native_pitch);
- SDL_UnlockTexture(native);
- } else {
- /* Use a temporary buffer for updating */
- void *temp_pixels;
- int temp_pitch;
-
- temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
- temp_pixels = SDL_malloc(rect->h * temp_pitch);
- if (!temp_pixels) {
- return SDL_OutOfMemory();
- }
- SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
- rect->w, rect->h, temp_pixels, temp_pitch);
- SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
- SDL_free(temp_pixels);
- }
- return 0;
-}
-
-static int
-SDL_UpdateTextureNative(SDL_Texture * texture, const SDL_Rect * rect,
- const void *pixels, int pitch)
-{
- SDL_Texture *native = texture->native;
-
- if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
- /* We can lock the texture and copy to it */
- void *native_pixels;
- int native_pitch;
-
- if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
- return -1;
- }
- SDL_ConvertPixels(rect->w, rect->h,
- texture->format, pixels, pitch,
- native->format, native_pixels, native_pitch);
- SDL_UnlockTexture(native);
- } else {
- /* Use a temporary buffer for updating */
- void *temp_pixels;
- int temp_pitch;
-
- temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
- temp_pixels = SDL_malloc(rect->h * temp_pitch);
- if (!temp_pixels) {
- return SDL_OutOfMemory();
- }
- SDL_ConvertPixels(rect->w, rect->h,
- texture->format, pixels, pitch,
- native->format, temp_pixels, temp_pitch);
- SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
- SDL_free(temp_pixels);
- }
- return 0;
-}
-
-int
-SDL_UpdateTexture(SDL_Texture * texture, const SDL_Rect * rect,
- const void *pixels, int pitch)
-{
- SDL_Renderer *renderer;
- SDL_Rect full_rect;
-
- CHECK_TEXTURE_MAGIC(texture, -1);
-
- if (!pixels) {
- return SDL_InvalidParamError("pixels");
- }
- if (!pitch) {
- return SDL_InvalidParamError("pitch");
- }
-
- if (!rect) {
- full_rect.x = 0;
- full_rect.y = 0;
- full_rect.w = texture->w;
- full_rect.h = texture->h;
- rect = &full_rect;
- }
-
- if ((rect->w == 0) || (rect->h == 0)) {
- return 0; /* nothing to do. */
- } else if (texture->yuv) {
- return SDL_UpdateTextureYUV(texture, rect, pixels, pitch);
- } else if (texture->native) {
- return SDL_UpdateTextureNative(texture, rect, pixels, pitch);
- } else {
- renderer = texture->renderer;
- return renderer->UpdateTexture(renderer, texture, rect, pixels, pitch);
- }
-}
-
-static int
-SDL_UpdateTextureYUVPlanar(SDL_Texture * texture, const SDL_Rect * rect,
- const Uint8 *Yplane, int Ypitch,
- const Uint8 *Uplane, int Upitch,
- const Uint8 *Vplane, int Vpitch)
-{
- SDL_Texture *native = texture->native;
- SDL_Rect full_rect;
-
- if (SDL_SW_UpdateYUVTexturePlanar(texture->yuv, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch) < 0) {
- return -1;
- }
-
- full_rect.x = 0;
- full_rect.y = 0;
- full_rect.w = texture->w;
- full_rect.h = texture->h;
- rect = &full_rect;
-
- if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
- /* We can lock the texture and copy to it */
- void *native_pixels;
- int native_pitch;
-
- if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
- return -1;
- }
- SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
- rect->w, rect->h, native_pixels, native_pitch);
- SDL_UnlockTexture(native);
- } else {
- /* Use a temporary buffer for updating */
- void *temp_pixels;
- int temp_pitch;
-
- temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
- temp_pixels = SDL_malloc(rect->h * temp_pitch);
- if (!temp_pixels) {
- return SDL_OutOfMemory();
- }
- SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
- rect->w, rect->h, temp_pixels, temp_pitch);
- SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
- SDL_free(temp_pixels);
- }
- return 0;
-}
-
-int SDL_UpdateYUVTexture(SDL_Texture * texture, const SDL_Rect * rect,
- const Uint8 *Yplane, int Ypitch,
- const Uint8 *Uplane, int Upitch,
- const Uint8 *Vplane, int Vpitch)
-{
- SDL_Renderer *renderer;
- SDL_Rect full_rect;
-
- CHECK_TEXTURE_MAGIC(texture, -1);
-
- if (!Yplane) {
- return SDL_InvalidParamError("Yplane");
- }
- if (!Ypitch) {
- return SDL_InvalidParamError("Ypitch");
- }
- if (!Uplane) {
- return SDL_InvalidParamError("Uplane");
- }
- if (!Upitch) {
- return SDL_InvalidParamError("Upitch");
- }
- if (!Vplane) {
- return SDL_InvalidParamError("Vplane");
- }
- if (!Vpitch) {
- return SDL_InvalidParamError("Vpitch");
- }
-
- if (texture->format != SDL_PIXELFORMAT_YV12 &&
- texture->format != SDL_PIXELFORMAT_IYUV) {
- return SDL_SetError("Texture format must by YV12 or IYUV");
- }
-
- if (!rect) {
- full_rect.x = 0;
- full_rect.y = 0;
- full_rect.w = texture->w;
- full_rect.h = texture->h;
- rect = &full_rect;
- }
-
- if (texture->yuv) {
- return SDL_UpdateTextureYUVPlanar(texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
- } else {
- SDL_assert(!texture->native);
- renderer = texture->renderer;
- SDL_assert(renderer->UpdateTextureYUV);
- if (renderer->UpdateTextureYUV) {
- return renderer->UpdateTextureYUV(renderer, texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
- } else {
- return SDL_Unsupported();
- }
- }
-}
-
-static int
-SDL_LockTextureYUV(SDL_Texture * texture, const SDL_Rect * rect,
- void **pixels, int *pitch)
-{
- return SDL_SW_LockYUVTexture(texture->yuv, rect, pixels, pitch);
-}
-
-static int
-SDL_LockTextureNative(SDL_Texture * texture, const SDL_Rect * rect,
- void **pixels, int *pitch)
-{
- texture->locked_rect = *rect;
- *pixels = (void *) ((Uint8 *) texture->pixels +
- rect->y * texture->pitch +
- rect->x * SDL_BYTESPERPIXEL(texture->format));
- *pitch = texture->pitch;
- return 0;
-}
-
-int
-SDL_LockTexture(SDL_Texture * texture, const SDL_Rect * rect,
- void **pixels, int *pitch)
-{
- SDL_Renderer *renderer;
- SDL_Rect full_rect;
-
- CHECK_TEXTURE_MAGIC(texture, -1);
-
- if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
- return SDL_SetError("SDL_LockTexture(): texture must be streaming");
- }
-
- if (!rect) {
- full_rect.x = 0;
- full_rect.y = 0;
- full_rect.w = texture->w;
- full_rect.h = texture->h;
- rect = &full_rect;
- }
-
- if (texture->yuv) {
- return SDL_LockTextureYUV(texture, rect, pixels, pitch);
- } else if (texture->native) {
- return SDL_LockTextureNative(texture, rect, pixels, pitch);
- } else {
- renderer = texture->renderer;
- return renderer->LockTexture(renderer, texture, rect, pixels, pitch);
- }
-}
-
-static void
-SDL_UnlockTextureYUV(SDL_Texture * texture)
-{
- SDL_Texture *native = texture->native;
- void *native_pixels = NULL;
- int native_pitch = 0;
- SDL_Rect rect;
-
- rect.x = 0;
- rect.y = 0;
- rect.w = texture->w;
- rect.h = texture->h;
-
- if (SDL_LockTexture(native, &rect, &native_pixels, &native_pitch) < 0) {
- return;
- }
- SDL_SW_CopyYUVToRGB(texture->yuv, &rect, native->format,
- rect.w, rect.h, native_pixels, native_pitch);
- SDL_UnlockTexture(native);
-}
-
-static void
-SDL_UnlockTextureNative(SDL_Texture * texture)
-{
- SDL_Texture *native = texture->native;
- void *native_pixels = NULL;
- int native_pitch = 0;
- const SDL_Rect *rect = &texture->locked_rect;
- const void* pixels = (void *) ((Uint8 *) texture->pixels +
- rect->y * texture->pitch +
- rect->x * SDL_BYTESPERPIXEL(texture->format));
- int pitch = texture->pitch;
-
- if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
- return;
- }
- SDL_ConvertPixels(rect->w, rect->h,
- texture->format, pixels, pitch,
- native->format, native_pixels, native_pitch);
- SDL_UnlockTexture(native);
-}
-
-void
-SDL_UnlockTexture(SDL_Texture * texture)
-{
- SDL_Renderer *renderer;
-
- CHECK_TEXTURE_MAGIC(texture, );
-
- if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
- return;
- }
- if (texture->yuv) {
- SDL_UnlockTextureYUV(texture);
- } else if (texture->native) {
- SDL_UnlockTextureNative(texture);
- } else {
- renderer = texture->renderer;
- renderer->UnlockTexture(renderer, texture);
- }
-}
-
-SDL_bool
-SDL_RenderTargetSupported(SDL_Renderer *renderer)
-{
- if (!renderer || !renderer->SetRenderTarget) {
- return SDL_FALSE;
- }
- return (renderer->info.flags & SDL_RENDERER_TARGETTEXTURE) != 0;
-}
-
-int
-SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
-{
- if (!SDL_RenderTargetSupported(renderer)) {
- return SDL_Unsupported();
- }
- if (texture == renderer->target) {
- /* Nothing to do! */
- return 0;
- }
-
- /* texture == NULL is valid and means reset the target to the window */
- if (texture) {
- CHECK_TEXTURE_MAGIC(texture, -1);
- if (renderer != texture->renderer) {
- return SDL_SetError("Texture was not created with this renderer");
- }
- if (texture->access != SDL_TEXTUREACCESS_TARGET) {
- return SDL_SetError("Texture not created with SDL_TEXTUREACCESS_TARGET");
- }
- if (texture->native) {
- /* Always render to the native texture */
- texture = texture->native;
- }
- }
-
- if (texture && !renderer->target) {
- /* Make a backup of the viewport */
- renderer->viewport_backup = renderer->viewport;
- renderer->clip_rect_backup = renderer->clip_rect;
- renderer->clipping_enabled_backup = renderer->clipping_enabled;
- renderer->scale_backup = renderer->scale;
- renderer->logical_w_backup = renderer->logical_w;
- renderer->logical_h_backup = renderer->logical_h;
- }
- renderer->target = texture;
-
- if (renderer->SetRenderTarget(renderer, texture) < 0) {
- return -1;
- }
-
- if (texture) {
- renderer->viewport.x = 0;
- renderer->viewport.y = 0;
- renderer->viewport.w = texture->w;
- renderer->viewport.h = texture->h;
- SDL_zero(renderer->clip_rect);
- renderer->clipping_enabled = SDL_FALSE;
- renderer->scale.x = 1.0f;
- renderer->scale.y = 1.0f;
- renderer->logical_w = texture->w;
- renderer->logical_h = texture->h;
- } else {
- renderer->viewport = renderer->viewport_backup;
- renderer->clip_rect = renderer->clip_rect_backup;
- renderer->clipping_enabled = renderer->clipping_enabled_backup;
- renderer->scale = renderer->scale_backup;
- renderer->logical_w = renderer->logical_w_backup;
- renderer->logical_h = renderer->logical_h_backup;
- }
- if (renderer->UpdateViewport(renderer) < 0) {
- return -1;
- }
- if (renderer->UpdateClipRect(renderer) < 0) {
- return -1;
- }
-
- /* All set! */
- return 0;
-}
-
-SDL_Texture *
-SDL_GetRenderTarget(SDL_Renderer *renderer)
-{
- return renderer->target;
-}
-
-static int
-UpdateLogicalSize(SDL_Renderer *renderer)
-{
- int w = 1, h = 1;
- float want_aspect;
- float real_aspect;
- float scale;
- SDL_Rect viewport;
-
- if (!renderer->logical_w || !renderer->logical_h) {
- return 0;
- }
- if (SDL_GetRendererOutputSize(renderer, &w, &h) < 0) {
- return -1;
- }
-
- want_aspect = (float)renderer->logical_w / renderer->logical_h;
- real_aspect = (float)w / h;
-
- /* Clear the scale because we're setting viewport in output coordinates */
- SDL_RenderSetScale(renderer, 1.0f, 1.0f);
-
- if (renderer->integer_scale) {
- if (want_aspect > real_aspect) {
- scale = (float)(w / renderer->logical_w);
- } else {
- scale = (float)(h / renderer->logical_h);
- }
- viewport.w = (int)SDL_ceil(renderer->logical_w * scale);
- viewport.x = (w - viewport.w) / 2;
- viewport.h = (int)SDL_ceil(renderer->logical_h * scale);
- viewport.y = (h - viewport.h) / 2;
-
- SDL_RenderSetViewport(renderer, &viewport);
- } else if (SDL_fabs(want_aspect-real_aspect) < 0.0001) {
- /* The aspect ratios are the same, just scale appropriately */
- scale = (float)w / renderer->logical_w;
- SDL_RenderSetViewport(renderer, NULL);
- } else if (want_aspect > real_aspect) {
- /* We want a wider aspect ratio than is available - letterbox it */
- scale = (float)w / renderer->logical_w;
- viewport.x = 0;
- viewport.w = w;
- viewport.h = (int)SDL_ceil(renderer->logical_h * scale);
- viewport.y = (h - viewport.h) / 2;
- SDL_RenderSetViewport(renderer, &viewport);
- } else {
- /* We want a narrower aspect ratio than is available - use side-bars */
- scale = (float)h / renderer->logical_h;
- viewport.y = 0;
- viewport.h = h;
- viewport.w = (int)SDL_ceil(renderer->logical_w * scale);
- viewport.x = (w - viewport.w) / 2;
- SDL_RenderSetViewport(renderer, &viewport);
- }
-
- /* Set the new scale */
- SDL_RenderSetScale(renderer, scale, scale);
-
- return 0;
-}
-
-int
-SDL_RenderSetLogicalSize(SDL_Renderer * renderer, int w, int h)
-{
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- if (!w || !h) {
- /* Clear any previous logical resolution */
- renderer->logical_w = 0;
- renderer->logical_h = 0;
- SDL_RenderSetViewport(renderer, NULL);
- SDL_RenderSetScale(renderer, 1.0f, 1.0f);
- return 0;
- }
-
- renderer->logical_w = w;
- renderer->logical_h = h;
-
- return UpdateLogicalSize(renderer);
-}
-
-void
-SDL_RenderGetLogicalSize(SDL_Renderer * renderer, int *w, int *h)
-{
- CHECK_RENDERER_MAGIC(renderer, );
-
- if (w) {
- *w = renderer->logical_w;
- }
- if (h) {
- *h = renderer->logical_h;
- }
-}
-
-int
-SDL_RenderSetIntegerScale(SDL_Renderer * renderer, SDL_bool enable)
-{
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- renderer->integer_scale = enable;
-
- return UpdateLogicalSize(renderer);
-}
-
-SDL_bool
-SDLCALL SDL_RenderGetIntegerScale(SDL_Renderer * renderer)
-{
- CHECK_RENDERER_MAGIC(renderer, SDL_FALSE);
-
- return renderer->integer_scale;
-}
-
-int
-SDL_RenderSetViewport(SDL_Renderer * renderer, const SDL_Rect * rect)
-{
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- if (rect) {
- renderer->viewport.x = (int)SDL_floor(rect->x * renderer->scale.x);
- renderer->viewport.y = (int)SDL_floor(rect->y * renderer->scale.y);
- renderer->viewport.w = (int)SDL_ceil(rect->w * renderer->scale.x);
- renderer->viewport.h = (int)SDL_ceil(rect->h * renderer->scale.y);
- } else {
- renderer->viewport.x = 0;
- renderer->viewport.y = 0;
- if (SDL_GetRendererOutputSize(renderer, &renderer->viewport.w, &renderer->viewport.h) < 0) {
- return -1;
- }
- }
- return renderer->UpdateViewport(renderer);
-}
-
-void
-SDL_RenderGetViewport(SDL_Renderer * renderer, SDL_Rect * rect)
-{
- CHECK_RENDERER_MAGIC(renderer, );
-
- if (rect) {
- rect->x = (int)(renderer->viewport.x / renderer->scale.x);
- rect->y = (int)(renderer->viewport.y / renderer->scale.y);
- rect->w = (int)(renderer->viewport.w / renderer->scale.x);
- rect->h = (int)(renderer->viewport.h / renderer->scale.y);
- }
-}
-
-int
-SDL_RenderSetClipRect(SDL_Renderer * renderer, const SDL_Rect * rect)
-{
- CHECK_RENDERER_MAGIC(renderer, -1)
-
- if (rect) {
- renderer->clipping_enabled = SDL_TRUE;
- renderer->clip_rect.x = (int)SDL_floor(rect->x * renderer->scale.x);
- renderer->clip_rect.y = (int)SDL_floor(rect->y * renderer->scale.y);
- renderer->clip_rect.w = (int)SDL_ceil(rect->w * renderer->scale.x);
- renderer->clip_rect.h = (int)SDL_ceil(rect->h * renderer->scale.y);
- } else {
- renderer->clipping_enabled = SDL_FALSE;
- SDL_zero(renderer->clip_rect);
- }
- return renderer->UpdateClipRect(renderer);
-}
-
-void
-SDL_RenderGetClipRect(SDL_Renderer * renderer, SDL_Rect * rect)
-{
- CHECK_RENDERER_MAGIC(renderer, )
-
- if (rect) {
- rect->x = (int)(renderer->clip_rect.x / renderer->scale.x);
- rect->y = (int)(renderer->clip_rect.y / renderer->scale.y);
- rect->w = (int)(renderer->clip_rect.w / renderer->scale.x);
- rect->h = (int)(renderer->clip_rect.h / renderer->scale.y);
- }
-}
-
-SDL_bool
-SDL_RenderIsClipEnabled(SDL_Renderer * renderer)
-{
- CHECK_RENDERER_MAGIC(renderer, SDL_FALSE)
- return renderer->clipping_enabled;
-}
-
-int
-SDL_RenderSetScale(SDL_Renderer * renderer, float scaleX, float scaleY)
-{
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- renderer->scale.x = scaleX;
- renderer->scale.y = scaleY;
- return 0;
-}
-
-void
-SDL_RenderGetScale(SDL_Renderer * renderer, float *scaleX, float *scaleY)
-{
- CHECK_RENDERER_MAGIC(renderer, );
-
- if (scaleX) {
- *scaleX = renderer->scale.x;
- }
- if (scaleY) {
- *scaleY = renderer->scale.y;
- }
-}
-
-int
-SDL_SetRenderDrawColor(SDL_Renderer * renderer,
- Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- renderer->r = r;
- renderer->g = g;
- renderer->b = b;
- renderer->a = a;
- return 0;
-}
-
-int
-SDL_GetRenderDrawColor(SDL_Renderer * renderer,
- Uint8 * r, Uint8 * g, Uint8 * b, Uint8 * a)
-{
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- if (r) {
- *r = renderer->r;
- }
- if (g) {
- *g = renderer->g;
- }
- if (b) {
- *b = renderer->b;
- }
- if (a) {
- *a = renderer->a;
- }
- return 0;
-}
-
-int
-SDL_SetRenderDrawBlendMode(SDL_Renderer * renderer, SDL_BlendMode blendMode)
-{
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- renderer->blendMode = blendMode;
- return 0;
-}
-
-int
-SDL_GetRenderDrawBlendMode(SDL_Renderer * renderer, SDL_BlendMode *blendMode)
-{
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- *blendMode = renderer->blendMode;
- return 0;
-}
-
-int
-SDL_RenderClear(SDL_Renderer * renderer)
-{
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- /* Don't draw while we're hidden */
- if (renderer->hidden) {
- return 0;
- }
- return renderer->RenderClear(renderer);
-}
-
-int
-SDL_RenderDrawPoint(SDL_Renderer * renderer, int x, int y)
-{
- SDL_Point point;
-
- point.x = x;
- point.y = y;
- return SDL_RenderDrawPoints(renderer, &point, 1);
-}
-
-static int
-RenderDrawPointsWithRects(SDL_Renderer * renderer,
- const SDL_Point * points, int count)
-{
- SDL_FRect *frects;
- int i;
- int status;
-
- frects = SDL_stack_alloc(SDL_FRect, count);
- if (!frects) {
- return SDL_OutOfMemory();
- }
- for (i = 0; i < count; ++i) {
- frects[i].x = points[i].x * renderer->scale.x;
- frects[i].y = points[i].y * renderer->scale.y;
- frects[i].w = renderer->scale.x;
- frects[i].h = renderer->scale.y;
- }
-
- status = renderer->RenderFillRects(renderer, frects, count);
-
- SDL_stack_free(frects);
-
- return status;
-}
-
-int
-SDL_RenderDrawPoints(SDL_Renderer * renderer,
- const SDL_Point * points, int count)
-{
- SDL_FPoint *fpoints;
- int i;
- int status;
-
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- if (!points) {
- return SDL_SetError("SDL_RenderDrawPoints(): Passed NULL points");
- }
- if (count < 1) {
- return 0;
- }
-
- /* Don't draw while we're hidden */
- if (renderer->hidden) {
- return 0;
- }
-
- if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
- return RenderDrawPointsWithRects(renderer, points, count);
- }
-
- fpoints = SDL_stack_alloc(SDL_FPoint, count);
- if (!fpoints) {
- return SDL_OutOfMemory();
- }
- for (i = 0; i < count; ++i) {
- fpoints[i].x = points[i].x * renderer->scale.x;
- fpoints[i].y = points[i].y * renderer->scale.y;
- }
-
- status = renderer->RenderDrawPoints(renderer, fpoints, count);
-
- SDL_stack_free(fpoints);
-
- return status;
-}
-
-int
-SDL_RenderDrawLine(SDL_Renderer * renderer, int x1, int y1, int x2, int y2)
-{
- SDL_Point points[2];
-
- points[0].x = x1;
- points[0].y = y1;
- points[1].x = x2;
- points[1].y = y2;
- return SDL_RenderDrawLines(renderer, points, 2);
-}
-
-static int
-RenderDrawLinesWithRects(SDL_Renderer * renderer,
- const SDL_Point * points, int count)
-{
- SDL_FRect *frect;
- SDL_FRect *frects;
- SDL_FPoint fpoints[2];
- int i, nrects;
- int status;
-
- frects = SDL_stack_alloc(SDL_FRect, count-1);
- if (!frects) {
- return SDL_OutOfMemory();
- }
-
- status = 0;
- nrects = 0;
- for (i = 0; i < count-1; ++i) {
- if (points[i].x == points[i+1].x) {
- int minY = SDL_min(points[i].y, points[i+1].y);
- int maxY = SDL_max(points[i].y, points[i+1].y);
-
- frect = &frects[nrects++];
- frect->x = points[i].x * renderer->scale.x;
- frect->y = minY * renderer->scale.y;
- frect->w = renderer->scale.x;
- frect->h = (maxY - minY + 1) * renderer->scale.y;
- } else if (points[i].y == points[i+1].y) {
- int minX = SDL_min(points[i].x, points[i+1].x);
- int maxX = SDL_max(points[i].x, points[i+1].x);
-
- frect = &frects[nrects++];
- frect->x = minX * renderer->scale.x;
- frect->y = points[i].y * renderer->scale.y;
- frect->w = (maxX - minX + 1) * renderer->scale.x;
- frect->h = renderer->scale.y;
- } else {
- /* FIXME: We can't use a rect for this line... */
- fpoints[0].x = points[i].x * renderer->scale.x;
- fpoints[0].y = points[i].y * renderer->scale.y;
- fpoints[1].x = points[i+1].x * renderer->scale.x;
- fpoints[1].y = points[i+1].y * renderer->scale.y;
- status += renderer->RenderDrawLines(renderer, fpoints, 2);
- }
- }
-
- status += renderer->RenderFillRects(renderer, frects, nrects);
-
- SDL_stack_free(frects);
-
- if (status < 0) {
- status = -1;
- }
- return status;
-}
-
-int
-SDL_RenderDrawLines(SDL_Renderer * renderer,
- const SDL_Point * points, int count)
-{
- SDL_FPoint *fpoints;
- int i;
- int status;
-
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- if (!points) {
- return SDL_SetError("SDL_RenderDrawLines(): Passed NULL points");
- }
- if (count < 2) {
- return 0;
- }
-
- /* Don't draw while we're hidden */
- if (renderer->hidden) {
- return 0;
- }
-
- if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
- return RenderDrawLinesWithRects(renderer, points, count);
- }
-
- fpoints = SDL_stack_alloc(SDL_FPoint, count);
- if (!fpoints) {
- return SDL_OutOfMemory();
- }
- for (i = 0; i < count; ++i) {
- fpoints[i].x = points[i].x * renderer->scale.x;
- fpoints[i].y = points[i].y * renderer->scale.y;
- }
-
- status = renderer->RenderDrawLines(renderer, fpoints, count);
-
- SDL_stack_free(fpoints);
-
- return status;
-}
-
-int
-SDL_RenderDrawRect(SDL_Renderer * renderer, const SDL_Rect * rect)
-{
- SDL_Rect full_rect;
- SDL_Point points[5];
-
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- /* If 'rect' == NULL, then outline the whole surface */
- if (!rect) {
- SDL_RenderGetViewport(renderer, &full_rect);
- full_rect.x = 0;
- full_rect.y = 0;
- rect = &full_rect;
- }
-
- points[0].x = rect->x;
- points[0].y = rect->y;
- points[1].x = rect->x+rect->w-1;
- points[1].y = rect->y;
- points[2].x = rect->x+rect->w-1;
- points[2].y = rect->y+rect->h-1;
- points[3].x = rect->x;
- points[3].y = rect->y+rect->h-1;
- points[4].x = rect->x;
- points[4].y = rect->y;
- return SDL_RenderDrawLines(renderer, points, 5);
-}
-
-int
-SDL_RenderDrawRects(SDL_Renderer * renderer,
- const SDL_Rect * rects, int count)
-{
- int i;
-
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- if (!rects) {
- return SDL_SetError("SDL_RenderDrawRects(): Passed NULL rects");
- }
- if (count < 1) {
- return 0;
- }
-
- /* Don't draw while we're hidden */
- if (renderer->hidden) {
- return 0;
- }
-
- for (i = 0; i < count; ++i) {
- if (SDL_RenderDrawRect(renderer, &rects[i]) < 0) {
- return -1;
- }
- }
- return 0;
-}
-
-int
-SDL_RenderFillRect(SDL_Renderer * renderer, const SDL_Rect * rect)
-{
- SDL_Rect full_rect = { 0, 0, 0, 0 };
-
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- /* If 'rect' == NULL, then outline the whole surface */
- if (!rect) {
- SDL_RenderGetViewport(renderer, &full_rect);
- full_rect.x = 0;
- full_rect.y = 0;
- rect = &full_rect;
- }
- return SDL_RenderFillRects(renderer, rect, 1);
-}
-
-int
-SDL_RenderFillRects(SDL_Renderer * renderer,
- const SDL_Rect * rects, int count)
-{
- SDL_FRect *frects;
- int i;
- int status;
-
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- if (!rects) {
- return SDL_SetError("SDL_RenderFillRects(): Passed NULL rects");
- }
- if (count < 1) {
- return 0;
- }
-
- /* Don't draw while we're hidden */
- if (renderer->hidden) {
- return 0;
- }
-
- frects = SDL_stack_alloc(SDL_FRect, count);
- if (!frects) {
- return SDL_OutOfMemory();
- }
- for (i = 0; i < count; ++i) {
- frects[i].x = rects[i].x * renderer->scale.x;
- frects[i].y = rects[i].y * renderer->scale.y;
- frects[i].w = rects[i].w * renderer->scale.x;
- frects[i].h = rects[i].h * renderer->scale.y;
- }
-
- status = renderer->RenderFillRects(renderer, frects, count);
-
- SDL_stack_free(frects);
-
- return status;
-}
-
-int
-SDL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
- const SDL_Rect * srcrect, const SDL_Rect * dstrect)
-{
- SDL_Rect real_srcrect = { 0, 0, 0, 0 };
- SDL_Rect real_dstrect = { 0, 0, 0, 0 };
- SDL_FRect frect;
-
- CHECK_RENDERER_MAGIC(renderer, -1);
- CHECK_TEXTURE_MAGIC(texture, -1);
-
- if (renderer != texture->renderer) {
- return SDL_SetError("Texture was not created with this renderer");
- }
-
- /* Don't draw while we're hidden */
- if (renderer->hidden) {
- return 0;
- }
-
- real_srcrect.x = 0;
- real_srcrect.y = 0;
- real_srcrect.w = texture->w;
- real_srcrect.h = texture->h;
- if (srcrect) {
- if (!SDL_IntersectRect(srcrect, &real_srcrect, &real_srcrect)) {
- return 0;
- }
- }
-
- SDL_RenderGetViewport(renderer, &real_dstrect);
- real_dstrect.x = 0;
- real_dstrect.y = 0;
- if (dstrect) {
- if (!SDL_HasIntersection(dstrect, &real_dstrect)) {
- return 0;
- }
- real_dstrect = *dstrect;
- }
-
- if (texture->native) {
- texture = texture->native;
- }
-
- frect.x = real_dstrect.x * renderer->scale.x;
- frect.y = real_dstrect.y * renderer->scale.y;
- frect.w = real_dstrect.w * renderer->scale.x;
- frect.h = real_dstrect.h * renderer->scale.y;
-
- return renderer->RenderCopy(renderer, texture, &real_srcrect, &frect);
-}
-
-
-int
-SDL_RenderCopyEx(SDL_Renderer * renderer, SDL_Texture * texture,
- const SDL_Rect * srcrect, const SDL_Rect * dstrect,
- const double angle, const SDL_Point *center, const SDL_RendererFlip flip)
-{
- SDL_Rect real_srcrect = { 0, 0, 0, 0 };
- SDL_Rect real_dstrect = { 0, 0, 0, 0 };
- SDL_Point real_center;
- SDL_FRect frect;
- SDL_FPoint fcenter;
-
- if (flip == SDL_FLIP_NONE && (int)(angle/360) == angle/360) { /* fast path when we don't need rotation or flipping */
- return SDL_RenderCopy(renderer, texture, srcrect, dstrect);
- }
-
- CHECK_RENDERER_MAGIC(renderer, -1);
- CHECK_TEXTURE_MAGIC(texture, -1);
-
- if (renderer != texture->renderer) {
- return SDL_SetError("Texture was not created with this renderer");
- }
- if (!renderer->RenderCopyEx) {
- return SDL_SetError("Renderer does not support RenderCopyEx");
- }
-
- /* Don't draw while we're hidden */
- if (renderer->hidden) {
- return 0;
- }
-
- real_srcrect.x = 0;
- real_srcrect.y = 0;
- real_srcrect.w = texture->w;
- real_srcrect.h = texture->h;
- if (srcrect) {
- if (!SDL_IntersectRect(srcrect, &real_srcrect, &real_srcrect)) {
- return 0;
- }
- }
-
- /* We don't intersect the dstrect with the viewport as RenderCopy does because of potential rotation clipping issues... TODO: should we? */
- if (dstrect) {
- real_dstrect = *dstrect;
- } else {
- SDL_RenderGetViewport(renderer, &real_dstrect);
- real_dstrect.x = 0;
- real_dstrect.y = 0;
- }
-
- if (texture->native) {
- texture = texture->native;
- }
-
- if (center) {
- real_center = *center;
- } else {
- real_center.x = real_dstrect.w/2;
- real_center.y = real_dstrect.h/2;
- }
-
- frect.x = real_dstrect.x * renderer->scale.x;
- frect.y = real_dstrect.y * renderer->scale.y;
- frect.w = real_dstrect.w * renderer->scale.x;
- frect.h = real_dstrect.h * renderer->scale.y;
-
- fcenter.x = real_center.x * renderer->scale.x;
- fcenter.y = real_center.y * renderer->scale.y;
-
- return renderer->RenderCopyEx(renderer, texture, &real_srcrect, &frect, angle, &fcenter, flip);
-}
-
-int
-SDL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
- Uint32 format, void * pixels, int pitch)
-{
- SDL_Rect real_rect;
-
- CHECK_RENDERER_MAGIC(renderer, -1);
-
- if (!renderer->RenderReadPixels) {
- return SDL_Unsupported();
- }
-
- if (!format) {
- format = SDL_GetWindowPixelFormat(renderer->window);
- }
-
- real_rect.x = renderer->viewport.x;
- real_rect.y = renderer->viewport.y;
- real_rect.w = renderer->viewport.w;
- real_rect.h = renderer->viewport.h;
- if (rect) {
- if (!SDL_IntersectRect(rect, &real_rect, &real_rect)) {
- return 0;
- }
- if (real_rect.y > rect->y) {
- pixels = (Uint8 *)pixels + pitch * (real_rect.y - rect->y);
- }
- if (real_rect.x > rect->x) {
- int bpp = SDL_BYTESPERPIXEL(format);
- pixels = (Uint8 *)pixels + bpp * (real_rect.x - rect->x);
- }
- }
-
- return renderer->RenderReadPixels(renderer, &real_rect,
- format, pixels, pitch);
-}
-
-void
-SDL_RenderPresent(SDL_Renderer * renderer)
-{
- CHECK_RENDERER_MAGIC(renderer, );
-
- /* Don't draw while we're hidden */
- if (renderer->hidden) {
- return;
- }
- renderer->RenderPresent(renderer);
-}
-
-void
-SDL_DestroyTexture(SDL_Texture * texture)
-{
- SDL_Renderer *renderer;
-
- CHECK_TEXTURE_MAGIC(texture, );
-
- renderer = texture->renderer;
- if (texture == renderer->target) {
- SDL_SetRenderTarget(renderer, NULL);
- }
-
- texture->magic = NULL;
-
- if (texture->next) {
- texture->next->prev = texture->prev;
- }
- if (texture->prev) {
- texture->prev->next = texture->next;
- } else {
- renderer->textures = texture->next;
- }
-
- if (texture->native) {
- SDL_DestroyTexture(texture->native);
- }
- if (texture->yuv) {
- SDL_SW_DestroyYUVTexture(texture->yuv);
- }
- SDL_free(texture->pixels);
-
- renderer->DestroyTexture(renderer, texture);
- SDL_free(texture);
-}
-
-void
-SDL_DestroyRenderer(SDL_Renderer * renderer)
-{
- CHECK_RENDERER_MAGIC(renderer, );
-
- SDL_DelEventWatch(SDL_RendererEventWatch, renderer);
-
- /* Free existing textures for this renderer */
- while (renderer->textures) {
- SDL_DestroyTexture(renderer->textures);
- }
-
- if (renderer->window) {
- SDL_SetWindowData(renderer->window, SDL_WINDOWRENDERDATA, NULL);
- }
-
- /* It's no longer magical... */
- renderer->magic = NULL;
-
- /* Free the renderer instance */
- renderer->DestroyRenderer(renderer);
-}
-
-int SDL_GL_BindTexture(SDL_Texture *texture, float *texw, float *texh)
-{
- SDL_Renderer *renderer;
-
- CHECK_TEXTURE_MAGIC(texture, -1);
- renderer = texture->renderer;
- if (texture->native) {
- return SDL_GL_BindTexture(texture->native, texw, texh);
- } else if (renderer && renderer->GL_BindTexture) {
- return renderer->GL_BindTexture(renderer, texture, texw, texh);
- } else {
- return SDL_Unsupported();
- }
-}
-
-int SDL_GL_UnbindTexture(SDL_Texture *texture)
-{
- SDL_Renderer *renderer;
-
- CHECK_TEXTURE_MAGIC(texture, -1);
- renderer = texture->renderer;
- if (texture->native) {
- return SDL_GL_UnbindTexture(texture->native);
- } else if (renderer && renderer->GL_UnbindTexture) {
- return renderer->GL_UnbindTexture(renderer, texture);
- }
-
- return SDL_Unsupported();
-}
-
-/* vi: set ts=4 sw=4 expandtab: */