summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/SDL2/src/render/software/SDL_render_sw.c
diff options
context:
space:
mode:
author Miodrag Milanovic <mmicko@gmail.com>2016-02-27 16:28:05 +0100
committer Miodrag Milanovic <mmicko@gmail.com>2016-02-27 16:53:49 +0100
commitcf6dc7d370407914020f3e623719f09c8668c692 (patch)
tree46b3416d091b4c09b50fba7ffcbd310aed032cc8 /3rdparty/SDL2/src/render/software/SDL_render_sw.c
parent64135e73f973d9b95beb0c60b65feb34fbfec64a (diff)
Placed SDL2 source since we need it on some platforms (nw)
Diffstat (limited to '3rdparty/SDL2/src/render/software/SDL_render_sw.c')
-rw-r--r--3rdparty/SDL2/src/render/software/SDL_render_sw.c794
1 files changed, 794 insertions, 0 deletions
diff --git a/3rdparty/SDL2/src/render/software/SDL_render_sw.c b/3rdparty/SDL2/src/render/software/SDL_render_sw.c
new file mode 100644
index 00000000000..dadd2442f96
--- /dev/null
+++ b/3rdparty/SDL2/src/render/software/SDL_render_sw.c
@@ -0,0 +1,794 @@
+/*
+ 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"
+
+#if !SDL_RENDER_DISABLED
+
+#include "../SDL_sysrender.h"
+#include "SDL_render_sw_c.h"
+#include "SDL_hints.h"
+
+#include "SDL_draw.h"
+#include "SDL_blendfillrect.h"
+#include "SDL_blendline.h"
+#include "SDL_blendpoint.h"
+#include "SDL_drawline.h"
+#include "SDL_drawpoint.h"
+#include "SDL_rotate.h"
+
+/* SDL surface based renderer implementation */
+
+static SDL_Renderer *SW_CreateRenderer(SDL_Window * window, Uint32 flags);
+static void SW_WindowEvent(SDL_Renderer * renderer,
+ const SDL_WindowEvent *event);
+static int SW_GetOutputSize(SDL_Renderer * renderer, int *w, int *h);
+static int SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
+static int SW_SetTextureColorMod(SDL_Renderer * renderer,
+ SDL_Texture * texture);
+static int SW_SetTextureAlphaMod(SDL_Renderer * renderer,
+ SDL_Texture * texture);
+static int SW_SetTextureBlendMode(SDL_Renderer * renderer,
+ SDL_Texture * texture);
+static int SW_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
+ const SDL_Rect * rect, const void *pixels,
+ int pitch);
+static int SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
+ const SDL_Rect * rect, void **pixels, int *pitch);
+static void SW_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);
+static int SW_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture);
+static int SW_UpdateViewport(SDL_Renderer * renderer);
+static int SW_UpdateClipRect(SDL_Renderer * renderer);
+static int SW_RenderClear(SDL_Renderer * renderer);
+static int SW_RenderDrawPoints(SDL_Renderer * renderer,
+ const SDL_FPoint * points, int count);
+static int SW_RenderDrawLines(SDL_Renderer * renderer,
+ const SDL_FPoint * points, int count);
+static int SW_RenderFillRects(SDL_Renderer * renderer,
+ const SDL_FRect * rects, int count);
+static int SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
+ const SDL_Rect * srcrect, const SDL_FRect * dstrect);
+static int SW_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 SW_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
+ Uint32 format, void * pixels, int pitch);
+static void SW_RenderPresent(SDL_Renderer * renderer);
+static void SW_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture);
+static void SW_DestroyRenderer(SDL_Renderer * renderer);
+
+
+SDL_RenderDriver SW_RenderDriver = {
+ SW_CreateRenderer,
+ {
+ "software",
+ SDL_RENDERER_SOFTWARE | SDL_RENDERER_TARGETTEXTURE,
+ 8,
+ {
+ SDL_PIXELFORMAT_ARGB8888,
+ SDL_PIXELFORMAT_ABGR8888,
+ SDL_PIXELFORMAT_RGBA8888,
+ SDL_PIXELFORMAT_BGRA8888,
+ SDL_PIXELFORMAT_RGB888,
+ SDL_PIXELFORMAT_BGR888,
+ SDL_PIXELFORMAT_RGB565,
+ SDL_PIXELFORMAT_RGB555
+ },
+ 0,
+ 0}
+};
+
+typedef struct
+{
+ SDL_Surface *surface;
+ SDL_Surface *window;
+} SW_RenderData;
+
+
+static SDL_Surface *
+SW_ActivateRenderer(SDL_Renderer * renderer)
+{
+ SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
+
+ if (!data->surface) {
+ data->surface = data->window;
+ }
+ if (!data->surface) {
+ SDL_Surface *surface = SDL_GetWindowSurface(renderer->window);
+ if (surface) {
+ data->surface = data->window = surface;
+
+ SW_UpdateViewport(renderer);
+ SW_UpdateClipRect(renderer);
+ }
+ }
+ return data->surface;
+}
+
+SDL_Renderer *
+SW_CreateRendererForSurface(SDL_Surface * surface)
+{
+ SDL_Renderer *renderer;
+ SW_RenderData *data;
+
+ if (!surface) {
+ SDL_SetError("Can't create renderer for NULL surface");
+ return NULL;
+ }
+
+ renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
+ if (!renderer) {
+ SDL_OutOfMemory();
+ return NULL;
+ }
+
+ data = (SW_RenderData *) SDL_calloc(1, sizeof(*data));
+ if (!data) {
+ SW_DestroyRenderer(renderer);
+ SDL_OutOfMemory();
+ return NULL;
+ }
+ data->surface = surface;
+ data->window = surface;
+
+ renderer->WindowEvent = SW_WindowEvent;
+ renderer->GetOutputSize = SW_GetOutputSize;
+ renderer->CreateTexture = SW_CreateTexture;
+ renderer->SetTextureColorMod = SW_SetTextureColorMod;
+ renderer->SetTextureAlphaMod = SW_SetTextureAlphaMod;
+ renderer->SetTextureBlendMode = SW_SetTextureBlendMode;
+ renderer->UpdateTexture = SW_UpdateTexture;
+ renderer->LockTexture = SW_LockTexture;
+ renderer->UnlockTexture = SW_UnlockTexture;
+ renderer->SetRenderTarget = SW_SetRenderTarget;
+ renderer->UpdateViewport = SW_UpdateViewport;
+ renderer->UpdateClipRect = SW_UpdateClipRect;
+ renderer->RenderClear = SW_RenderClear;
+ renderer->RenderDrawPoints = SW_RenderDrawPoints;
+ renderer->RenderDrawLines = SW_RenderDrawLines;
+ renderer->RenderFillRects = SW_RenderFillRects;
+ renderer->RenderCopy = SW_RenderCopy;
+ renderer->RenderCopyEx = SW_RenderCopyEx;
+ renderer->RenderReadPixels = SW_RenderReadPixels;
+ renderer->RenderPresent = SW_RenderPresent;
+ renderer->DestroyTexture = SW_DestroyTexture;
+ renderer->DestroyRenderer = SW_DestroyRenderer;
+ renderer->info = SW_RenderDriver.info;
+ renderer->driverdata = data;
+
+ SW_ActivateRenderer(renderer);
+
+ return renderer;
+}
+
+SDL_Renderer *
+SW_CreateRenderer(SDL_Window * window, Uint32 flags)
+{
+ SDL_Surface *surface;
+
+ surface = SDL_GetWindowSurface(window);
+ if (!surface) {
+ return NULL;
+ }
+ return SW_CreateRendererForSurface(surface);
+}
+
+static void
+SW_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
+{
+ SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
+
+ if (event->event == SDL_WINDOWEVENT_SIZE_CHANGED) {
+ data->surface = NULL;
+ data->window = NULL;
+ }
+}
+
+static int
+SW_GetOutputSize(SDL_Renderer * renderer, int *w, int *h)
+{
+ SDL_Surface *surface = SW_ActivateRenderer(renderer);
+
+ if (surface) {
+ if (w) {
+ *w = surface->w;
+ }
+ if (h) {
+ *h = surface->h;
+ }
+ return 0;
+ } else {
+ SDL_SetError("Software renderer doesn't have an output surface");
+ return -1;
+ }
+}
+
+static int
+SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+ int bpp;
+ Uint32 Rmask, Gmask, Bmask, Amask;
+
+ if (!SDL_PixelFormatEnumToMasks
+ (texture->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
+ return SDL_SetError("Unknown texture format");
+ }
+
+ texture->driverdata =
+ SDL_CreateRGBSurface(0, texture->w, texture->h, bpp, Rmask, Gmask,
+ Bmask, Amask);
+ SDL_SetSurfaceColorMod(texture->driverdata, texture->r, texture->g,
+ texture->b);
+ SDL_SetSurfaceAlphaMod(texture->driverdata, texture->a);
+ SDL_SetSurfaceBlendMode(texture->driverdata, texture->blendMode);
+
+ if (texture->access == SDL_TEXTUREACCESS_STATIC) {
+ SDL_SetSurfaceRLE(texture->driverdata, 1);
+ }
+
+ if (!texture->driverdata) {
+ return -1;
+ }
+ return 0;
+}
+
+static int
+SW_SetTextureColorMod(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+ SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
+ /* If the color mod is ever enabled (non-white), permanently disable RLE (which doesn't support
+ * color mod) to avoid potentially frequent RLE encoding/decoding.
+ */
+ if ((texture->r & texture->g & texture->b) != 255) {
+ SDL_SetSurfaceRLE(surface, 0);
+ }
+ return SDL_SetSurfaceColorMod(surface, texture->r, texture->g,
+ texture->b);
+}
+
+static int
+SW_SetTextureAlphaMod(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+ SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
+ /* If the texture ever has multiple alpha values (surface alpha plus alpha channel), permanently
+ * disable RLE (which doesn't support this) to avoid potentially frequent RLE encoding/decoding.
+ */
+ if (texture->a != 255 && surface->format->Amask) {
+ SDL_SetSurfaceRLE(surface, 0);
+ }
+ return SDL_SetSurfaceAlphaMod(surface, texture->a);
+}
+
+static int
+SW_SetTextureBlendMode(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+ SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
+ /* If add or mod blending are ever enabled, permanently disable RLE (which doesn't support
+ * them) to avoid potentially frequent RLE encoding/decoding.
+ */
+ if ((texture->blendMode == SDL_BLENDMODE_ADD || texture->blendMode == SDL_BLENDMODE_MOD)) {
+ SDL_SetSurfaceRLE(surface, 0);
+ }
+ return SDL_SetSurfaceBlendMode(surface, texture->blendMode);
+}
+
+static int
+SW_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
+ const SDL_Rect * rect, const void *pixels, int pitch)
+{
+ SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
+ Uint8 *src, *dst;
+ int row;
+ size_t length;
+
+ if(SDL_MUSTLOCK(surface))
+ SDL_LockSurface(surface);
+ src = (Uint8 *) pixels;
+ dst = (Uint8 *) surface->pixels +
+ rect->y * surface->pitch +
+ rect->x * surface->format->BytesPerPixel;
+ length = rect->w * surface->format->BytesPerPixel;
+ for (row = 0; row < rect->h; ++row) {
+ SDL_memcpy(dst, src, length);
+ src += pitch;
+ dst += surface->pitch;
+ }
+ if(SDL_MUSTLOCK(surface))
+ SDL_UnlockSurface(surface);
+ return 0;
+}
+
+static int
+SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
+ const SDL_Rect * rect, void **pixels, int *pitch)
+{
+ SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
+
+ *pixels =
+ (void *) ((Uint8 *) surface->pixels + rect->y * surface->pitch +
+ rect->x * surface->format->BytesPerPixel);
+ *pitch = surface->pitch;
+ return 0;
+}
+
+static void
+SW_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+}
+
+static int
+SW_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+ SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
+
+ if (texture ) {
+ data->surface = (SDL_Surface *) texture->driverdata;
+ } else {
+ data->surface = data->window;
+ }
+ return 0;
+}
+
+static int
+SW_UpdateViewport(SDL_Renderer * renderer)
+{
+ SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
+ SDL_Surface *surface = data->surface;
+
+ if (!surface) {
+ /* We'll update the viewport after we recreate the surface */
+ return 0;
+ }
+
+ SDL_SetClipRect(data->surface, &renderer->viewport);
+ return 0;
+}
+
+static int
+SW_UpdateClipRect(SDL_Renderer * renderer)
+{
+ SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
+ SDL_Surface *surface = data->surface;
+ if (surface) {
+ if (renderer->clipping_enabled) {
+ SDL_SetClipRect(surface, &renderer->clip_rect);
+ } else {
+ SDL_SetClipRect(surface, NULL);
+ }
+ }
+ return 0;
+}
+
+static int
+SW_RenderClear(SDL_Renderer * renderer)
+{
+ SDL_Surface *surface = SW_ActivateRenderer(renderer);
+ Uint32 color;
+ SDL_Rect clip_rect;
+
+ if (!surface) {
+ return -1;
+ }
+
+ color = SDL_MapRGBA(surface->format,
+ renderer->r, renderer->g, renderer->b, renderer->a);
+
+ /* By definition the clear ignores the clip rect */
+ clip_rect = surface->clip_rect;
+ SDL_SetClipRect(surface, NULL);
+ SDL_FillRect(surface, NULL, color);
+ SDL_SetClipRect(surface, &clip_rect);
+ return 0;
+}
+
+static int
+SW_RenderDrawPoints(SDL_Renderer * renderer, const SDL_FPoint * points,
+ int count)
+{
+ SDL_Surface *surface = SW_ActivateRenderer(renderer);
+ SDL_Point *final_points;
+ int i, status;
+
+ if (!surface) {
+ return -1;
+ }
+
+ final_points = SDL_stack_alloc(SDL_Point, count);
+ if (!final_points) {
+ return SDL_OutOfMemory();
+ }
+ if (renderer->viewport.x || renderer->viewport.y) {
+ int x = renderer->viewport.x;
+ int y = renderer->viewport.y;
+
+ for (i = 0; i < count; ++i) {
+ final_points[i].x = (int)(x + points[i].x);
+ final_points[i].y = (int)(y + points[i].y);
+ }
+ } else {
+ for (i = 0; i < count; ++i) {
+ final_points[i].x = (int)points[i].x;
+ final_points[i].y = (int)points[i].y;
+ }
+ }
+
+ /* Draw the points! */
+ if (renderer->blendMode == SDL_BLENDMODE_NONE) {
+ Uint32 color = SDL_MapRGBA(surface->format,
+ renderer->r, renderer->g, renderer->b,
+ renderer->a);
+
+ status = SDL_DrawPoints(surface, final_points, count, color);
+ } else {
+ status = SDL_BlendPoints(surface, final_points, count,
+ renderer->blendMode,
+ renderer->r, renderer->g, renderer->b,
+ renderer->a);
+ }
+ SDL_stack_free(final_points);
+
+ return status;
+}
+
+static int
+SW_RenderDrawLines(SDL_Renderer * renderer, const SDL_FPoint * points,
+ int count)
+{
+ SDL_Surface *surface = SW_ActivateRenderer(renderer);
+ SDL_Point *final_points;
+ int i, status;
+
+ if (!surface) {
+ return -1;
+ }
+
+ final_points = SDL_stack_alloc(SDL_Point, count);
+ if (!final_points) {
+ return SDL_OutOfMemory();
+ }
+ if (renderer->viewport.x || renderer->viewport.y) {
+ int x = renderer->viewport.x;
+ int y = renderer->viewport.y;
+
+ for (i = 0; i < count; ++i) {
+ final_points[i].x = (int)(x + points[i].x);
+ final_points[i].y = (int)(y + points[i].y);
+ }
+ } else {
+ for (i = 0; i < count; ++i) {
+ final_points[i].x = (int)points[i].x;
+ final_points[i].y = (int)points[i].y;
+ }
+ }
+
+ /* Draw the lines! */
+ if (renderer->blendMode == SDL_BLENDMODE_NONE) {
+ Uint32 color = SDL_MapRGBA(surface->format,
+ renderer->r, renderer->g, renderer->b,
+ renderer->a);
+
+ status = SDL_DrawLines(surface, final_points, count, color);
+ } else {
+ status = SDL_BlendLines(surface, final_points, count,
+ renderer->blendMode,
+ renderer->r, renderer->g, renderer->b,
+ renderer->a);
+ }
+ SDL_stack_free(final_points);
+
+ return status;
+}
+
+static int
+SW_RenderFillRects(SDL_Renderer * renderer, const SDL_FRect * rects, int count)
+{
+ SDL_Surface *surface = SW_ActivateRenderer(renderer);
+ SDL_Rect *final_rects;
+ int i, status;
+
+ if (!surface) {
+ return -1;
+ }
+
+ final_rects = SDL_stack_alloc(SDL_Rect, count);
+ if (!final_rects) {
+ return SDL_OutOfMemory();
+ }
+ if (renderer->viewport.x || renderer->viewport.y) {
+ int x = renderer->viewport.x;
+ int y = renderer->viewport.y;
+
+ for (i = 0; i < count; ++i) {
+ final_rects[i].x = (int)(x + rects[i].x);
+ final_rects[i].y = (int)(y + rects[i].y);
+ final_rects[i].w = SDL_max((int)rects[i].w, 1);
+ final_rects[i].h = SDL_max((int)rects[i].h, 1);
+ }
+ } else {
+ for (i = 0; i < count; ++i) {
+ final_rects[i].x = (int)rects[i].x;
+ final_rects[i].y = (int)rects[i].y;
+ final_rects[i].w = SDL_max((int)rects[i].w, 1);
+ final_rects[i].h = SDL_max((int)rects[i].h, 1);
+ }
+ }
+
+ if (renderer->blendMode == SDL_BLENDMODE_NONE) {
+ Uint32 color = SDL_MapRGBA(surface->format,
+ renderer->r, renderer->g, renderer->b,
+ renderer->a);
+ status = SDL_FillRects(surface, final_rects, count, color);
+ } else {
+ status = SDL_BlendFillRects(surface, final_rects, count,
+ renderer->blendMode,
+ renderer->r, renderer->g, renderer->b,
+ renderer->a);
+ }
+ SDL_stack_free(final_rects);
+
+ return status;
+}
+
+static int
+SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
+ const SDL_Rect * srcrect, const SDL_FRect * dstrect)
+{
+ SDL_Surface *surface = SW_ActivateRenderer(renderer);
+ SDL_Surface *src = (SDL_Surface *) texture->driverdata;
+ SDL_Rect final_rect;
+
+ if (!surface) {
+ return -1;
+ }
+
+ if (renderer->viewport.x || renderer->viewport.y) {
+ final_rect.x = (int)(renderer->viewport.x + dstrect->x);
+ final_rect.y = (int)(renderer->viewport.y + dstrect->y);
+ } else {
+ final_rect.x = (int)dstrect->x;
+ final_rect.y = (int)dstrect->y;
+ }
+ final_rect.w = (int)dstrect->w;
+ final_rect.h = (int)dstrect->h;
+
+ if ( srcrect->w == final_rect.w && srcrect->h == final_rect.h ) {
+ return SDL_BlitSurface(src, srcrect, surface, &final_rect);
+ } else {
+ /* If scaling is ever done, permanently disable RLE (which doesn't support scaling)
+ * to avoid potentially frequent RLE encoding/decoding.
+ */
+ SDL_SetSurfaceRLE(surface, 0);
+ return SDL_BlitScaled(src, srcrect, surface, &final_rect);
+ }
+}
+
+static int
+GetScaleQuality(void)
+{
+ const char *hint = SDL_GetHint(SDL_HINT_RENDER_SCALE_QUALITY);
+
+ if (!hint || *hint == '0' || SDL_strcasecmp(hint, "nearest") == 0) {
+ return 0;
+ } else {
+ return 1;
+ }
+}
+
+static int
+SW_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)
+{
+ SDL_Surface *surface = SW_ActivateRenderer(renderer);
+ SDL_Surface *src = (SDL_Surface *) texture->driverdata;
+ SDL_Rect final_rect, tmp_rect;
+ SDL_Surface *surface_rotated, *surface_scaled;
+ int retval, dstwidth, dstheight, abscenterx, abscentery;
+ double cangle, sangle, px, py, p1x, p1y, p2x, p2y, p3x, p3y, p4x, p4y;
+
+ if (!surface) {
+ return -1;
+ }
+
+ if (renderer->viewport.x || renderer->viewport.y) {
+ final_rect.x = (int)(renderer->viewport.x + dstrect->x);
+ final_rect.y = (int)(renderer->viewport.y + dstrect->y);
+ } else {
+ final_rect.x = (int)dstrect->x;
+ final_rect.y = (int)dstrect->y;
+ }
+ final_rect.w = (int)dstrect->w;
+ final_rect.h = (int)dstrect->h;
+
+ /* SDLgfx_rotateSurface doesn't accept a source rectangle, so crop and scale if we need to */
+ tmp_rect = final_rect;
+ tmp_rect.x = 0;
+ tmp_rect.y = 0;
+ if (srcrect->w == final_rect.w && srcrect->h == final_rect.h && srcrect->x == 0 && srcrect->y == 0) {
+ surface_scaled = src; /* but if we don't need to, just use the original */
+ retval = 0;
+ } else {
+ SDL_Surface *blit_src = src;
+ Uint32 colorkey;
+ SDL_BlendMode blendMode;
+ Uint8 alphaMod, r, g, b;
+ SDL_bool cloneSource = SDL_FALSE;
+
+ surface_scaled = SDL_CreateRGBSurface(SDL_SWSURFACE, final_rect.w, final_rect.h, src->format->BitsPerPixel,
+ src->format->Rmask, src->format->Gmask,
+ src->format->Bmask, src->format->Amask );
+ if (!surface_scaled) {
+ return -1;
+ }
+
+ /* copy the color key, alpha mod, blend mode, and color mod so the scaled surface behaves like the source */
+ if (SDL_GetColorKey(src, &colorkey) == 0) {
+ SDL_SetColorKey(surface_scaled, SDL_TRUE, colorkey);
+ cloneSource = SDL_TRUE;
+ }
+ SDL_GetSurfaceAlphaMod(src, &alphaMod); /* these will be copied to surface_scaled below if necessary */
+ SDL_GetSurfaceBlendMode(src, &blendMode);
+ SDL_GetSurfaceColorMod(src, &r, &g, &b);
+
+ /* now we need to blit the src into surface_scaled. since we want to copy the colors from the source to
+ * surface_scaled rather than blend them, etc. we'll need to disable the blend mode, alpha mod, etc.
+ * but we don't want to modify src (in case it's being used on other threads), so we'll need to clone it
+ * before changing the blend options
+ */
+ cloneSource |= blendMode != SDL_BLENDMODE_NONE || (alphaMod & r & g & b) != 255;
+ if (cloneSource) {
+ blit_src = SDL_ConvertSurface(src, src->format, src->flags); /* clone src */
+ if (!blit_src) {
+ SDL_FreeSurface(surface_scaled);
+ return -1;
+ }
+ SDL_SetSurfaceAlphaMod(blit_src, 255); /* disable all blending options in blit_src */
+ SDL_SetSurfaceBlendMode(blit_src, SDL_BLENDMODE_NONE);
+ SDL_SetColorKey(blit_src, 0, 0);
+ SDL_SetSurfaceColorMod(blit_src, 255, 255, 255);
+ SDL_SetSurfaceRLE(blit_src, 0); /* don't RLE encode a surface we'll only use once */
+
+ SDL_SetSurfaceAlphaMod(surface_scaled, alphaMod); /* copy blending options to surface_scaled */
+ SDL_SetSurfaceBlendMode(surface_scaled, blendMode);
+ SDL_SetSurfaceColorMod(surface_scaled, r, g, b);
+ }
+
+ retval = SDL_BlitScaled(blit_src, srcrect, surface_scaled, &tmp_rect);
+ if (blit_src != src) {
+ SDL_FreeSurface(blit_src);
+ }
+ }
+
+ if (!retval) {
+ SDLgfx_rotozoomSurfaceSizeTrig(tmp_rect.w, tmp_rect.h, -angle, &dstwidth, &dstheight, &cangle, &sangle);
+ surface_rotated = SDLgfx_rotateSurface(surface_scaled, -angle, dstwidth/2, dstheight/2, GetScaleQuality(), flip & SDL_FLIP_HORIZONTAL, flip & SDL_FLIP_VERTICAL, dstwidth, dstheight, cangle, sangle);
+ if(surface_rotated) {
+ /* Find out where the new origin is by rotating the four final_rect points around the center and then taking the extremes */
+ abscenterx = final_rect.x + (int)center->x;
+ abscentery = final_rect.y + (int)center->y;
+ /* Compensate the angle inversion to match the behaviour of the other backends */
+ sangle = -sangle;
+
+ /* Top Left */
+ px = final_rect.x - abscenterx;
+ py = final_rect.y - abscentery;
+ p1x = px * cangle - py * sangle + abscenterx;
+ p1y = px * sangle + py * cangle + abscentery;
+
+ /* Top Right */
+ px = final_rect.x + final_rect.w - abscenterx;
+ py = final_rect.y - abscentery;
+ p2x = px * cangle - py * sangle + abscenterx;
+ p2y = px * sangle + py * cangle + abscentery;
+
+ /* Bottom Left */
+ px = final_rect.x - abscenterx;
+ py = final_rect.y + final_rect.h - abscentery;
+ p3x = px * cangle - py * sangle + abscenterx;
+ p3y = px * sangle + py * cangle + abscentery;
+
+ /* Bottom Right */
+ px = final_rect.x + final_rect.w - abscenterx;
+ py = final_rect.y + final_rect.h - abscentery;
+ p4x = px * cangle - py * sangle + abscenterx;
+ p4y = px * sangle + py * cangle + abscentery;
+
+ tmp_rect.x = (int)MIN(MIN(p1x, p2x), MIN(p3x, p4x));
+ tmp_rect.y = (int)MIN(MIN(p1y, p2y), MIN(p3y, p4y));
+ tmp_rect.w = dstwidth;
+ tmp_rect.h = dstheight;
+
+ retval = SDL_BlitSurface(surface_rotated, NULL, surface, &tmp_rect);
+ SDL_FreeSurface(surface_rotated);
+ }
+ }
+
+ if (surface_scaled != src) {
+ SDL_FreeSurface(surface_scaled);
+ }
+ return retval;
+}
+
+static int
+SW_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
+ Uint32 format, void * pixels, int pitch)
+{
+ SDL_Surface *surface = SW_ActivateRenderer(renderer);
+ Uint32 src_format;
+ void *src_pixels;
+ SDL_Rect final_rect;
+
+ if (!surface) {
+ return -1;
+ }
+
+ if (renderer->viewport.x || renderer->viewport.y) {
+ final_rect.x = renderer->viewport.x + rect->x;
+ final_rect.y = renderer->viewport.y + rect->y;
+ final_rect.w = rect->w;
+ final_rect.h = rect->h;
+ rect = &final_rect;
+ }
+
+ if (rect->x < 0 || rect->x+rect->w > surface->w ||
+ rect->y < 0 || rect->y+rect->h > surface->h) {
+ return SDL_SetError("Tried to read outside of surface bounds");
+ }
+
+ src_format = surface->format->format;
+ src_pixels = (void*)((Uint8 *) surface->pixels +
+ rect->y * surface->pitch +
+ rect->x * surface->format->BytesPerPixel);
+
+ return SDL_ConvertPixels(rect->w, rect->h,
+ src_format, src_pixels, surface->pitch,
+ format, pixels, pitch);
+}
+
+static void
+SW_RenderPresent(SDL_Renderer * renderer)
+{
+ SDL_Window *window = renderer->window;
+
+ if (window) {
+ SDL_UpdateWindowSurface(window);
+ }
+}
+
+static void
+SW_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+ SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
+
+ SDL_FreeSurface(surface);
+}
+
+static void
+SW_DestroyRenderer(SDL_Renderer * renderer)
+{
+ SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
+
+ SDL_free(data);
+ SDL_free(renderer);
+}
+
+#endif /* !SDL_RENDER_DISABLED */
+
+/* vi: set ts=4 sw=4 expandtab: */