Making the API simpler, moved the surface drawing functions to the software renderer.
--- a/include/SDL_surface.h Thu Feb 03 02:42:50 2011 -0800
+++ b/include/SDL_surface.h Thu Feb 03 02:45:29 2011 -0800
@@ -364,85 +364,6 @@
void * dst, int dst_pitch);
/**
- * Draws a point with \c color.
- *
- * The color should be a pixel of the format used by the surface, and
- * can be generated by the SDL_MapRGB() function.
- *
- * \return 0 on success, or -1 on error.
- */
-extern DECLSPEC int SDLCALL SDL_DrawPoint
- (SDL_Surface * dst, int x, int y, Uint32 color);
-extern DECLSPEC int SDLCALL SDL_DrawPoints
- (SDL_Surface * dst, const SDL_Point * points, int count, Uint32 color);
-
-/**
- * Blends a point with an RGBA value.
- *
- * \return 0 on success, or -1 on error.
- */
-extern DECLSPEC int SDLCALL SDL_BlendPoint
- (SDL_Surface * dst, int x, int y,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
-extern DECLSPEC int SDLCALL SDL_BlendPoints
- (SDL_Surface * dst, const SDL_Point * points, int count,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
-
-/**
- * Draws a line with \c color.
- *
- * The color should be a pixel of the format used by the surface, and
- * can be generated by the SDL_MapRGB() function.
- *
- * \return 0 on success, or -1 on error.
- */
-extern DECLSPEC int SDLCALL SDL_DrawLine
- (SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color);
-extern DECLSPEC int SDLCALL SDL_DrawLines
- (SDL_Surface * dst, const SDL_Point * points, int count, Uint32 color);
-
-/**
- * Blends an RGBA value along a line.
- *
- * \return 0 on success, or -1 on error.
- */
-extern DECLSPEC int SDLCALL SDL_BlendLine
- (SDL_Surface * dst, int x1, int y1, int x2, int y2,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
-extern DECLSPEC int SDLCALL SDL_BlendLines
- (SDL_Surface * dst, const SDL_Point * points, int count,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
-
-/**
- * Draws the given rectangle with \c color.
- *
- * If \c rect is NULL, the whole surface will be outlined with \c color.
- *
- * The color should be a pixel of the format used by the surface, and
- * can be generated by the SDL_MapRGB() function.
- *
- * \return 0 on success, or -1 on error.
- */
-extern DECLSPEC int SDLCALL SDL_DrawRect
- (SDL_Surface * dst, const SDL_Rect * rect, Uint32 color);
-extern DECLSPEC int SDLCALL SDL_DrawRects
- (SDL_Surface * dst, const SDL_Rect ** rects, int count, Uint32 color);
-
-/**
- * Blends an RGBA value into the outline of the given rectangle.
- *
- * If \c rect is NULL, the whole surface will have a blended outline.
- *
- * \return 0 on success, or -1 on error.
- */
-extern DECLSPEC int SDLCALL SDL_BlendRect
- (SDL_Surface * dst, const SDL_Rect * rect,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
-extern DECLSPEC int SDLCALL SDL_BlendRects
- (SDL_Surface * dst, const SDL_Rect ** rects, int count,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
-
-/**
* Performs a fast fill of the given rectangle with \c color.
*
* If \c rect is NULL, the whole surface will be filled with \c color.
@@ -458,20 +379,6 @@
(SDL_Surface * dst, const SDL_Rect ** rects, int count, Uint32 color);
/**
- * Blends an RGBA value into the given rectangle.
- *
- * If \c rect is NULL, the whole surface will be blended with the color.
- *
- * \return This function returns 0 on success, or -1 on error.
- */
-extern DECLSPEC int SDLCALL SDL_BlendFillRect
- (SDL_Surface * dst, const SDL_Rect * rect,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
-extern DECLSPEC int SDLCALL SDL_BlendFillRects
- (SDL_Surface * dst, const SDL_Rect ** rects, int count,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
-
-/**
* Performs a fast blit from the source surface to the destination surface.
*
* This assumes that the source and destination rectangles are
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_blendfillrect.c Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,327 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2010 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"
+
+#include "SDL_draw.h"
+#include "SDL_blendfillrect.h"
+
+
+static int
+SDL_BlendFillRect_RGB555(SDL_Surface * dst, const SDL_Rect * rect,
+ SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+ unsigned inva = 0xff - a;
+
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB555);
+ break;
+ case SDL_BLENDMODE_ADD:
+ FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB555);
+ break;
+ default:
+ FILLRECT(Uint16, DRAW_SETPIXEL_RGB555);
+ break;
+ }
+ return 0;
+}
+
+static int
+SDL_BlendFillRect_RGB565(SDL_Surface * dst, const SDL_Rect * rect,
+ SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+ unsigned inva = 0xff - a;
+
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB565);
+ break;
+ case SDL_BLENDMODE_ADD:
+ FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB565);
+ break;
+ default:
+ FILLRECT(Uint16, DRAW_SETPIXEL_RGB565);
+ break;
+ }
+ return 0;
+}
+
+static int
+SDL_BlendFillRect_RGB888(SDL_Surface * dst, const SDL_Rect * rect,
+ SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+ unsigned inva = 0xff - a;
+
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGB888);
+ break;
+ case SDL_BLENDMODE_ADD:
+ FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGB888);
+ break;
+ default:
+ FILLRECT(Uint32, DRAW_SETPIXEL_RGB888);
+ break;
+ }
+ return 0;
+}
+
+static int
+SDL_BlendFillRect_ARGB8888(SDL_Surface * dst, const SDL_Rect * rect,
+ SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+ unsigned inva = 0xff - a;
+
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888);
+ break;
+ case SDL_BLENDMODE_ADD:
+ FILLRECT(Uint32, DRAW_SETPIXEL_ADD_ARGB8888);
+ break;
+ default:
+ FILLRECT(Uint32, DRAW_SETPIXEL_ARGB8888);
+ break;
+ }
+ return 0;
+}
+
+static int
+SDL_BlendFillRect_RGB(SDL_Surface * dst, const SDL_Rect * rect,
+ SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+ SDL_PixelFormat *fmt = dst->format;
+ unsigned inva = 0xff - a;
+
+ switch (fmt->BytesPerPixel) {
+ case 2:
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB);
+ break;
+ case SDL_BLENDMODE_ADD:
+ FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB);
+ break;
+ default:
+ FILLRECT(Uint16, DRAW_SETPIXEL_RGB);
+ break;
+ }
+ return 0;
+ case 4:
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGB);
+ break;
+ case SDL_BLENDMODE_ADD:
+ FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGB);
+ break;
+ default:
+ FILLRECT(Uint32, DRAW_SETPIXEL_RGB);
+ break;
+ }
+ return 0;
+ default:
+ SDL_Unsupported();
+ return -1;
+ }
+}
+
+static int
+SDL_BlendFillRect_RGBA(SDL_Surface * dst, const SDL_Rect * rect,
+ SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+ SDL_PixelFormat *fmt = dst->format;
+ unsigned inva = 0xff - a;
+
+ switch (fmt->BytesPerPixel) {
+ case 4:
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGBA);
+ break;
+ case SDL_BLENDMODE_ADD:
+ FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGBA);
+ break;
+ default:
+ FILLRECT(Uint32, DRAW_SETPIXEL_RGBA);
+ break;
+ }
+ return 0;
+ default:
+ SDL_Unsupported();
+ return -1;
+ }
+}
+
+int
+SDL_BlendFillRect(SDL_Surface * dst, const SDL_Rect * rect,
+ SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+ SDL_Rect clipped;
+
+ if (!dst) {
+ SDL_SetError("Passed NULL destination surface");
+ return -1;
+ }
+
+ /* This function doesn't work on surfaces < 8 bpp */
+ if (dst->format->BitsPerPixel < 8) {
+ SDL_SetError("SDL_BlendFillRect(): Unsupported surface format");
+ return -1;
+ }
+
+ /* If 'rect' == NULL, then fill the whole surface */
+ if (rect) {
+ /* Perform clipping */
+ if (!SDL_IntersectRect(rect, &dst->clip_rect, &clipped)) {
+ return 0;
+ }
+ rect = &clipped;
+ } else {
+ rect = &dst->clip_rect;
+ }
+
+ if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+ r = DRAW_MUL(r, a);
+ g = DRAW_MUL(g, a);
+ b = DRAW_MUL(b, a);
+ }
+
+ switch (dst->format->BitsPerPixel) {
+ case 15:
+ switch (dst->format->Rmask) {
+ case 0x7C00:
+ return SDL_BlendFillRect_RGB555(dst, rect, blendMode, r, g, b, a);
+ }
+ break;
+ case 16:
+ switch (dst->format->Rmask) {
+ case 0xF800:
+ return SDL_BlendFillRect_RGB565(dst, rect, blendMode, r, g, b, a);
+ }
+ break;
+ case 32:
+ switch (dst->format->Rmask) {
+ case 0x00FF0000:
+ if (!dst->format->Amask) {
+ return SDL_BlendFillRect_RGB888(dst, rect, blendMode, r, g, b, a);
+ } else {
+ return SDL_BlendFillRect_ARGB8888(dst, rect, blendMode, r, g, b, a);
+ }
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (!dst->format->Amask) {
+ return SDL_BlendFillRect_RGB(dst, rect, blendMode, r, g, b, a);
+ } else {
+ return SDL_BlendFillRect_RGBA(dst, rect, blendMode, r, g, b, a);
+ }
+}
+
+int
+SDL_BlendFillRects(SDL_Surface * dst, const SDL_Rect ** rects, int count,
+ SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+ SDL_Rect clipped;
+ int i;
+ int (*func)(SDL_Surface * dst, const SDL_Rect * rect,
+ SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a) = NULL;
+ int status = 0;
+
+ if (!dst) {
+ SDL_SetError("Passed NULL destination surface");
+ return -1;
+ }
+
+ /* This function doesn't work on surfaces < 8 bpp */
+ if (dst->format->BitsPerPixel < 8) {
+ SDL_SetError("SDL_BlendFillRects(): Unsupported surface format");
+ return -1;
+ }
+
+ if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+ r = DRAW_MUL(r, a);
+ g = DRAW_MUL(g, a);
+ b = DRAW_MUL(b, a);
+ }
+
+ /* FIXME: Does this function pointer slow things down significantly? */
+ switch (dst->format->BitsPerPixel) {
+ case 15:
+ switch (dst->format->Rmask) {
+ case 0x7C00:
+ func = SDL_BlendFillRect_RGB555;
+ }
+ break;
+ case 16:
+ switch (dst->format->Rmask) {
+ case 0xF800:
+ func = SDL_BlendFillRect_RGB565;
+ }
+ break;
+ case 32:
+ switch (dst->format->Rmask) {
+ case 0x00FF0000:
+ if (!dst->format->Amask) {
+ func = SDL_BlendFillRect_RGB888;
+ } else {
+ func = SDL_BlendFillRect_ARGB8888;
+ }
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (!func) {
+ if (!dst->format->Amask) {
+ func = SDL_BlendFillRect_RGB;
+ } else {
+ func = SDL_BlendFillRect_RGBA;
+ }
+ }
+
+ for (i = 0; i < count; ++i) {
+ const SDL_Rect * rect = rects[i];
+
+ /* If 'rect' == NULL, then fill the whole surface */
+ if (rect) {
+ /* Perform clipping */
+ if (!SDL_IntersectRect(rect, &dst->clip_rect, &clipped)) {
+ continue;
+ }
+ rect = &clipped;
+ } else {
+ rect = &dst->clip_rect;
+ }
+
+ status = func(dst, rect, blendMode, r, g, b, a);
+ }
+ return status;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_blendfillrect.h Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,28 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2010 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"
+
+
+extern int SDL_BlendFillRect(SDL_Surface * dst, const SDL_Rect * rect, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+extern int SDL_BlendFillRects(SDL_Surface * dst, const SDL_Rect ** rects, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_blendline.c Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,683 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2010 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"
+
+#include "SDL_draw.h"
+#include "SDL_blendline.h"
+
+
+static void
+SDL_BlendLine_RGB2(SDL_Surface * dst, int x1, int y1, int x2, int y2,
+ SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+ SDL_bool draw_end)
+{
+ const SDL_PixelFormat *fmt = dst->format;
+ unsigned r, g, b, a, inva;
+
+ if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+ r = DRAW_MUL(_r, _a);
+ g = DRAW_MUL(_g, _a);
+ b = DRAW_MUL(_b, _a);
+ a = _a;
+ } else {
+ r = _r;
+ g = _g;
+ b = _b;
+ a = _a;
+ }
+ inva = (a ^ 0xff);
+
+ if (y1 == y2) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
+ break;
+ default:
+ HLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
+ break;
+ }
+ } else if (x1 == x2) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
+ break;
+ default:
+ VLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
+ break;
+ }
+ } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
+ break;
+ default:
+ DLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
+ break;
+ }
+ } else {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY2_BLEND_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
+ draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY2_ADD_RGB, DRAW_SETPIXELXY2_ADD_RGB,
+ draw_end);
+ break;
+ default:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY2_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
+ draw_end);
+ break;
+ }
+ }
+}
+
+static void
+SDL_BlendLine_RGB555(SDL_Surface * dst, int x1, int y1, int x2, int y2,
+ SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+ SDL_bool draw_end)
+{
+ const SDL_PixelFormat *fmt = dst->format;
+ unsigned r, g, b, a, inva;
+
+ if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+ r = DRAW_MUL(_r, _a);
+ g = DRAW_MUL(_g, _a);
+ b = DRAW_MUL(_b, _a);
+ a = _a;
+ } else {
+ r = _r;
+ g = _g;
+ b = _b;
+ a = _a;
+ }
+ inva = (a ^ 0xff);
+
+ if (y1 == y2) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
+ break;
+ default:
+ HLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
+ break;
+ }
+ } else if (x1 == x2) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
+ break;
+ default:
+ VLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
+ break;
+ }
+ } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
+ break;
+ default:
+ DLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
+ break;
+ }
+ } else {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY_BLEND_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
+ draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY_ADD_RGB555, DRAW_SETPIXELXY_ADD_RGB555,
+ draw_end);
+ break;
+ default:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
+ draw_end);
+ break;
+ }
+ }
+}
+
+static void
+SDL_BlendLine_RGB565(SDL_Surface * dst, int x1, int y1, int x2, int y2,
+ SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+ SDL_bool draw_end)
+{
+ const SDL_PixelFormat *fmt = dst->format;
+ unsigned r, g, b, a, inva;
+
+ if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+ r = DRAW_MUL(_r, _a);
+ g = DRAW_MUL(_g, _a);
+ b = DRAW_MUL(_b, _a);
+ a = _a;
+ } else {
+ r = _r;
+ g = _g;
+ b = _b;
+ a = _a;
+ }
+ inva = (a ^ 0xff);
+
+ if (y1 == y2) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
+ break;
+ default:
+ HLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
+ break;
+ }
+ } else if (x1 == x2) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
+ break;
+ default:
+ VLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
+ break;
+ }
+ } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
+ break;
+ default:
+ DLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
+ break;
+ }
+ } else {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY_BLEND_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
+ draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY_ADD_RGB565, DRAW_SETPIXELXY_ADD_RGB565,
+ draw_end);
+ break;
+ default:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
+ draw_end);
+ break;
+ }
+ }
+}
+
+static void
+SDL_BlendLine_RGB4(SDL_Surface * dst, int x1, int y1, int x2, int y2,
+ SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+ SDL_bool draw_end)
+{
+ const SDL_PixelFormat *fmt = dst->format;
+ unsigned r, g, b, a, inva;
+
+ if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+ r = DRAW_MUL(_r, _a);
+ g = DRAW_MUL(_g, _a);
+ b = DRAW_MUL(_b, _a);
+ a = _a;
+ } else {
+ r = _r;
+ g = _g;
+ b = _b;
+ a = _a;
+ }
+ inva = (a ^ 0xff);
+
+ if (y1 == y2) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
+ break;
+ default:
+ HLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
+ break;
+ }
+ } else if (x1 == x2) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
+ break;
+ default:
+ VLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
+ break;
+ }
+ } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
+ break;
+ default:
+ DLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
+ break;
+ }
+ } else {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY4_BLEND_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
+ draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY4_ADD_RGB, DRAW_SETPIXELXY4_ADD_RGB,
+ draw_end);
+ break;
+ default:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY4_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
+ draw_end);
+ break;
+ }
+ }
+}
+
+static void
+SDL_BlendLine_RGBA4(SDL_Surface * dst, int x1, int y1, int x2, int y2,
+ SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+ SDL_bool draw_end)
+{
+ const SDL_PixelFormat *fmt = dst->format;
+ unsigned r, g, b, a, inva;
+
+ if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+ r = DRAW_MUL(_r, _a);
+ g = DRAW_MUL(_g, _a);
+ b = DRAW_MUL(_b, _a);
+ a = _a;
+ } else {
+ r = _r;
+ g = _g;
+ b = _b;
+ a = _a;
+ }
+ inva = (a ^ 0xff);
+
+ if (y1 == y2) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ HLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
+ break;
+ default:
+ HLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
+ break;
+ }
+ } else if (x1 == x2) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ VLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
+ break;
+ default:
+ VLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
+ break;
+ }
+ } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ DLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
+ break;
+ default:
+ DLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
+ break;
+ }
+ } else {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY4_BLEND_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
+ draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY4_ADD_RGBA, DRAW_SETPIXELXY4_ADD_RGBA,
+ draw_end);
+ break;
+ default:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY4_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
+ draw_end);
+ break;
+ }
+ }
+}
+
+static void
+SDL_BlendLine_RGB888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
+ SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+ SDL_bool draw_end)
+{
+ const SDL_PixelFormat *fmt = dst->format;
+ unsigned r, g, b, a, inva;
+
+ if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+ r = DRAW_MUL(_r, _a);
+ g = DRAW_MUL(_g, _a);
+ b = DRAW_MUL(_b, _a);
+ a = _a;
+ } else {
+ r = _r;
+ g = _g;
+ b = _b;
+ a = _a;
+ }
+ inva = (a ^ 0xff);
+
+ if (y1 == y2) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
+ break;
+ default:
+ HLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
+ break;
+ }
+ } else if (x1 == x2) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
+ break;
+ default:
+ VLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
+ break;
+ }
+ } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
+ break;
+ default:
+ DLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
+ break;
+ }
+ } else {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY_BLEND_RGB888, DRAW_SETPIXELXY_BLEND_RGB888,
+ draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY_ADD_RGB888, DRAW_SETPIXELXY_ADD_RGB888,
+ draw_end);
+ break;
+ default:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY_RGB888, DRAW_SETPIXELXY_BLEND_RGB888,
+ draw_end);
+ break;
+ }
+ }
+}
+
+static void
+SDL_BlendLine_ARGB8888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
+ SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+ SDL_bool draw_end)
+{
+ const SDL_PixelFormat *fmt = dst->format;
+ unsigned r, g, b, a, inva;
+
+ if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+ r = DRAW_MUL(_r, _a);
+ g = DRAW_MUL(_g, _a);
+ b = DRAW_MUL(_b, _a);
+ a = _a;
+ } else {
+ r = _r;
+ g = _g;
+ b = _b;
+ a = _a;
+ }
+ inva = (a ^ 0xff);
+
+ if (y1 == y2) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ HLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ HLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
+ break;
+ default:
+ HLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
+ break;
+ }
+ } else if (x1 == x2) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ VLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ VLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
+ break;
+ default:
+ VLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
+ break;
+ }
+ } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ DLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ DLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
+ break;
+ default:
+ DLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
+ break;
+ }
+ } else {
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY_BLEND_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
+ draw_end);
+ break;
+ case SDL_BLENDMODE_ADD:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY_ADD_ARGB8888, DRAW_SETPIXELXY_ADD_ARGB8888,
+ draw_end);
+ break;
+ default:
+ AALINE(x1, y1, x2, y2,
+ DRAW_SETPIXELXY_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
+ draw_end);
+ break;
+ }
+ }
+}
+
+typedef void (*BlendLineFunc) (SDL_Surface * dst,
+ int x1, int y1, int x2, int y2,
+ SDL_BlendMode blendMode,
+ Uint8 r, Uint8 g, Uint8 b, Uint8 a,
+ SDL_bool draw_end);
+
+static BlendLineFunc
+SDL_CalculateBlendLineFunc(const SDL_PixelFormat * fmt)
+{
+ switch (fmt->BytesPerPixel) {
+ case 2:
+ if (fmt->Rmask == 0x7C00) {
+ return SDL_BlendLine_RGB555;
+ } else if (fmt->Rmask == 0xF800) {
+ return SDL_BlendLine_RGB565;
+ } else {
+ return SDL_BlendLine_RGB2;
+ }
+ break;
+ case 4:
+ if (fmt->Rmask == 0x00FF0000) {
+ if (fmt->Amask) {
+ return SDL_BlendLine_ARGB8888;
+ } else {
+ return SDL_BlendLine_RGB888;
+ }
+ } else {
+ if (fmt->Amask) {
+ return SDL_BlendLine_RGBA4;
+ } else {
+ return SDL_BlendLine_RGB4;
+ }
+ }
+ }
+ return NULL;
+}
+
+int
+SDL_BlendLine(SDL_Surface * dst, int x1, int y1, int x2, int y2,
+ SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+ BlendLineFunc func;
+
+ if (!dst) {
+ SDL_SetError("SDL_BlendLine(): Passed NULL destination surface");
+ return -1;
+ }
+
+ func = SDL_CalculateBlendLineFunc(dst->format);
+ if (!func) {
+ SDL_SetError("SDL_BlendLine(): Unsupported surface format");
+ return -1;
+ }
+
+ /* Perform clipping */
+ /* FIXME: We don't actually want to clip, as it may change line slope */
+ if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
+ return 0;
+ }
+
+ func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, SDL_TRUE);
+ return 0;
+}
+
+int
+SDL_BlendLines(SDL_Surface * dst, const SDL_Point * points, int count,
+ SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+ int i;
+ int x1, y1;
+ int x2, y2;
+ SDL_bool draw_end;
+ BlendLineFunc func;
+
+ if (!dst) {
+ SDL_SetError("SDL_BlendLines(): Passed NULL destination surface");
+ return -1;
+ }
+
+ func = SDL_CalculateBlendLineFunc(dst->format);
+ if (!func) {
+ SDL_SetError("SDL_BlendLines(): Unsupported surface format");
+ return -1;
+ }
+
+ for (i = 1; i < count; ++i) {
+ x1 = points[i-1].x;
+ y1 = points[i-1].y;
+ x2 = points[i].x;
+ y2 = points[i].y;
+
+ /* Perform clipping */
+ /* FIXME: We don't actually want to clip, as it may change line slope */
+ if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
+ continue;
+ }
+
+ /* Draw the end if it was clipped */
+ draw_end = (x2 != points[i].x || y2 != points[i].y);
+
+ func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, draw_end);
+ }
+ if (points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
+ SDL_BlendPoint(dst, points[count-1].x, points[count-1].y,
+ blendMode, r, g, b, a);
+ }
+ return 0;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_blendline.h Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,28 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2010 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"
+
+
+extern int SDL_BlendLine(SDL_Surface * dst, int x1, int y1, int x2, int y2, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+extern int SDL_BlendLines(SDL_Surface * dst, const SDL_Point * points, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_blendpoint.c Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,325 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2010 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"
+
+#include "SDL_draw.h"
+#include "SDL_blendpoint.h"
+
+
+static int
+SDL_BlendPoint_RGB555(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+ Uint8 g, Uint8 b, Uint8 a)
+{
+ unsigned inva = 0xff - a;
+
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ DRAW_SETPIXELXY_BLEND_RGB555(x, y);
+ break;
+ case SDL_BLENDMODE_ADD:
+ DRAW_SETPIXELXY_ADD_RGB555(x, y);
+ break;
+ default:
+ DRAW_SETPIXELXY_RGB555(x, y);
+ break;
+ }
+ return 0;
+}
+
+static int
+SDL_BlendPoint_RGB565(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+ Uint8 g, Uint8 b, Uint8 a)
+{
+ unsigned inva = 0xff - a;
+
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ DRAW_SETPIXELXY_BLEND_RGB565(x, y);
+ break;
+ case SDL_BLENDMODE_ADD:
+ DRAW_SETPIXELXY_ADD_RGB565(x, y);
+ break;
+ default:
+ DRAW_SETPIXELXY_RGB565(x, y);
+ break;
+ }
+ return 0;
+}
+
+static int
+SDL_BlendPoint_RGB888(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+ Uint8 g, Uint8 b, Uint8 a)
+{
+ unsigned inva = 0xff - a;
+
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ DRAW_SETPIXELXY_BLEND_RGB888(x, y);
+ break;
+ case SDL_BLENDMODE_ADD:
+ DRAW_SETPIXELXY_ADD_RGB888(x, y);
+ break;
+ default:
+ DRAW_SETPIXELXY_RGB888(x, y);
+ break;
+ }
+ return 0;
+}
+
+static int
+SDL_BlendPoint_ARGB8888(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode,
+ Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+ unsigned inva = 0xff - a;
+
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ DRAW_SETPIXELXY_BLEND_ARGB8888(x, y);
+ break;
+ case SDL_BLENDMODE_ADD:
+ DRAW_SETPIXELXY_ADD_ARGB8888(x, y);
+ break;
+ default:
+ DRAW_SETPIXELXY_ARGB8888(x, y);
+ break;
+ }
+ return 0;
+}
+
+static int
+SDL_BlendPoint_RGB(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+ Uint8 g, Uint8 b, Uint8 a)
+{
+ SDL_PixelFormat *fmt = dst->format;
+ unsigned inva = 0xff - a;
+
+ switch (fmt->BytesPerPixel) {
+ case 2:
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ DRAW_SETPIXELXY2_BLEND_RGB(x, y);
+ break;
+ case SDL_BLENDMODE_ADD:
+ DRAW_SETPIXELXY2_ADD_RGB(x, y);
+ break;
+ default:
+ DRAW_SETPIXELXY2_RGB(x, y);
+ break;
+ }
+ return 0;
+ case 4:
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ DRAW_SETPIXELXY4_BLEND_RGB(x, y);
+ break;
+ case SDL_BLENDMODE_ADD:
+ DRAW_SETPIXELXY4_ADD_RGB(x, y);
+ break;
+ default:
+ DRAW_SETPIXELXY4_RGB(x, y);
+ break;
+ }
+ return 0;
+ default:
+ SDL_Unsupported();
+ return -1;
+ }
+}
+
+static int
+SDL_BlendPoint_RGBA(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+ Uint8 g, Uint8 b, Uint8 a)
+{
+ SDL_PixelFormat *fmt = dst->format;
+ unsigned inva = 0xff - a;
+
+ switch (fmt->BytesPerPixel) {
+ case 4:
+ switch (blendMode) {
+ case SDL_BLENDMODE_BLEND:
+ DRAW_SETPIXELXY4_BLEND_RGBA(x, y);
+ break;
+ case SDL_BLENDMODE_ADD:
+ DRAW_SETPIXELXY4_ADD_RGBA(x, y);
+ break;
+ default:
+ DRAW_SETPIXELXY4_RGBA(x, y);
+ break;
+ }
+ return 0;
+ default:
+ SDL_Unsupported();
+ return -1;
+ }
+}
+
+int
+SDL_BlendPoint(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+ Uint8 g, Uint8 b, Uint8 a)
+{
+ if (!dst) {
+ SDL_SetError("Passed NULL destination surface");
+ return -1;
+ }
+
+ /* This function doesn't work on surfaces < 8 bpp */
+ if (dst->format->BitsPerPixel < 8) {
+ SDL_SetError("SDL_BlendPoint(): Unsupported surface format");
+ return -1;
+ }
+
+ /* Perform clipping */
+ if (x < dst->clip_rect.x || y < dst->clip_rect.y ||
+ x >= (dst->clip_rect.x + dst->clip_rect.w) ||
+ y >= (dst->clip_rect.y + dst->clip_rect.h)) {
+ return 0;
+ }
+
+ if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+ r = DRAW_MUL(r, a);
+ g = DRAW_MUL(g, a);
+ b = DRAW_MUL(b, a);
+ }
+
+ switch (dst->format->BitsPerPixel) {
+ case 15:
+ switch (dst->format->Rmask) {
+ case 0x7C00:
+ return SDL_BlendPoint_RGB555(dst, x, y, blendMode, r, g, b, a);
+ }
+ break;
+ case 16:
+ switch (dst->format->Rmask) {
+ case 0xF800:
+ return SDL_BlendPoint_RGB565(dst, x, y, blendMode, r, g, b, a);
+ }
+ break;
+ case 32:
+ switch (dst->format->Rmask) {
+ case 0x00FF0000:
+ if (!dst->format->Amask) {
+ return SDL_BlendPoint_RGB888(dst, x, y, blendMode, r, g, b,
+ a);
+ } else {
+ return SDL_BlendPoint_ARGB8888(dst, x, y, blendMode, r, g, b,
+ a);
+ }
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (!dst->format->Amask) {
+ return SDL_BlendPoint_RGB(dst, x, y, blendMode, r, g, b, a);
+ } else {
+ return SDL_BlendPoint_RGBA(dst, x, y, blendMode, r, g, b, a);
+ }
+}
+
+int
+SDL_BlendPoints(SDL_Surface * dst, const SDL_Point * points, int count,
+ SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+ int minx, miny;
+ int maxx, maxy;
+ int i;
+ int x, y;
+ int (*func)(SDL_Surface * dst, int x, int y,
+ SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a) = NULL;
+ int status = 0;
+
+ if (!dst) {
+ SDL_SetError("Passed NULL destination surface");
+ return -1;
+ }
+
+ /* This function doesn't work on surfaces < 8 bpp */
+ if (dst->format->BitsPerPixel < 8) {
+ SDL_SetError("SDL_BlendPoints(): Unsupported surface format");
+ return (-1);
+ }
+
+ if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+ r = DRAW_MUL(r, a);
+ g = DRAW_MUL(g, a);
+ b = DRAW_MUL(b, a);
+ }
+
+ /* FIXME: Does this function pointer slow things down significantly? */
+ switch (dst->format->BitsPerPixel) {
+ case 15:
+ switch (dst->format->Rmask) {
+ case 0x7C00:
+ func = SDL_BlendPoint_RGB555;
+ break;
+ }
+ break;
+ case 16:
+ switch (dst->format->Rmask) {
+ case 0xF800:
+ func = SDL_BlendPoint_RGB565;
+ break;
+ }
+ break;
+ case 32:
+ switch (dst->format->Rmask) {
+ case 0x00FF0000:
+ if (!dst->format->Amask) {
+ func = SDL_BlendPoint_RGB888;
+ } else {
+ func = SDL_BlendPoint_ARGB8888;
+ }
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (!func) {
+ if (!dst->format->Amask) {
+ func = SDL_BlendPoint_RGB;
+ } else {
+ func = SDL_BlendPoint_RGBA;
+ }
+ }
+
+ minx = dst->clip_rect.x;
+ maxx = dst->clip_rect.x + dst->clip_rect.w - 1;
+ miny = dst->clip_rect.y;
+ maxy = dst->clip_rect.y + dst->clip_rect.h - 1;
+
+ for (i = 0; i < count; ++i) {
+ x = points[i].x;
+ y = points[i].y;
+
+ if (x < minx || x > maxx || y < miny || y > maxy) {
+ continue;
+ }
+ status = func(dst, x, y, blendMode, r, g, b, a);
+ }
+ return status;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_blendpoint.h Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,28 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2010 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"
+
+
+extern int SDL_BlendPoint(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+extern int SDL_BlendPoints(SDL_Surface * dst, const SDL_Point * points, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_draw.h Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,521 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2010 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"
+
+#include "../../video/SDL_blit.h"
+
+/* This code assumes that r, g, b, a are the source color,
+ * and in the blend and add case, the RGB values are premultiplied by a.
+ */
+
+#define DRAW_MUL(_a, _b) (((unsigned)(_a)*(_b))/255)
+
+#define DRAW_FASTSETPIXEL(type) \
+ *pixel = (type) color
+
+#define DRAW_FASTSETPIXEL1 DRAW_FASTSETPIXEL(Uint8)
+#define DRAW_FASTSETPIXEL2 DRAW_FASTSETPIXEL(Uint16)
+#define DRAW_FASTSETPIXEL4 DRAW_FASTSETPIXEL(Uint32)
+
+#define DRAW_FASTSETPIXELXY(x, y, type, bpp, color) \
+ *(type *)((Uint8 *)dst->pixels + (y) * dst->pitch \
+ + (x) * bpp) = (type) color
+
+#define DRAW_FASTSETPIXELXY1(x, y) DRAW_FASTSETPIXELXY(x, y, Uint8, 1, color)
+#define DRAW_FASTSETPIXELXY2(x, y) DRAW_FASTSETPIXELXY(x, y, Uint16, 2, color)
+#define DRAW_FASTSETPIXELXY4(x, y) DRAW_FASTSETPIXELXY(x, y, Uint32, 4, color)
+
+#define DRAW_SETPIXEL(setpixel) \
+do { \
+ unsigned sr = r, sg = g, sb = b, sa = a; \
+ setpixel; \
+} while (0)
+
+#define DRAW_SETPIXEL_BLEND(getpixel, setpixel) \
+do { \
+ unsigned sr, sg, sb, sa; sa; \
+ getpixel; \
+ sr = DRAW_MUL(inva, sr) + r; \
+ sg = DRAW_MUL(inva, sg) + g; \
+ sb = DRAW_MUL(inva, sb) + b; \
+ setpixel; \
+} while (0)
+
+#define DRAW_SETPIXEL_ADD(getpixel, setpixel) \
+do { \
+ unsigned sr, sg, sb, sa; sa; \
+ getpixel; \
+ sr += r; if (sr > 0xff) sr = 0xff; \
+ sg += g; if (sg > 0xff) sg = 0xff; \
+ sb += b; if (sb > 0xff) sb = 0xff; \
+ setpixel; \
+} while (0)
+
+#define DRAW_SETPIXELXY(x, y, type, bpp, op) \
+do { \
+ type *pixel = (type *)((Uint8 *)dst->pixels + (y) * dst->pitch \
+ + (x) * bpp); \
+ op; \
+} while (0)
+
+/*
+ * Define draw operators for RGB555
+ */
+
+#define DRAW_SETPIXEL_RGB555 \
+ DRAW_SETPIXEL(RGB555_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_BLEND_RGB555 \
+ DRAW_SETPIXEL_BLEND(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
+ RGB555_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_ADD_RGB555 \
+ DRAW_SETPIXEL_ADD(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
+ RGB555_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXELXY_RGB555(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB555)
+
+#define DRAW_SETPIXELXY_BLEND_RGB555(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB555)
+
+#define DRAW_SETPIXELXY_ADD_RGB555(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB555)
+
+/*
+ * Define draw operators for RGB565
+ */
+
+#define DRAW_SETPIXEL_RGB565 \
+ DRAW_SETPIXEL(RGB565_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_BLEND_RGB565 \
+ DRAW_SETPIXEL_BLEND(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
+ RGB565_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_ADD_RGB565 \
+ DRAW_SETPIXEL_ADD(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
+ RGB565_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXELXY_RGB565(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB565)
+
+#define DRAW_SETPIXELXY_BLEND_RGB565(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB565)
+
+#define DRAW_SETPIXELXY_ADD_RGB565(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB565)
+
+/*
+ * Define draw operators for RGB888
+ */
+
+#define DRAW_SETPIXEL_RGB888 \
+ DRAW_SETPIXEL(RGB888_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_BLEND_RGB888 \
+ DRAW_SETPIXEL_BLEND(RGB_FROM_RGB888(*pixel, sr, sg, sb), \
+ RGB888_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_ADD_RGB888 \
+ DRAW_SETPIXEL_ADD(RGB_FROM_RGB888(*pixel, sr, sg, sb), \
+ RGB888_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXELXY_RGB888(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGB888)
+
+#define DRAW_SETPIXELXY_BLEND_RGB888(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGB888)
+
+#define DRAW_SETPIXELXY_ADD_RGB888(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGB888)
+
+/*
+ * Define draw operators for ARGB8888
+ */
+
+#define DRAW_SETPIXEL_ARGB8888 \
+ DRAW_SETPIXEL(ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_BLEND_ARGB8888 \
+ DRAW_SETPIXEL_BLEND(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
+ ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_ADD_ARGB8888 \
+ DRAW_SETPIXEL_ADD(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
+ ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
+
+#define DRAW_SETPIXELXY_ARGB8888(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ARGB8888)
+
+#define DRAW_SETPIXELXY_BLEND_ARGB8888(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_ARGB8888)
+
+#define DRAW_SETPIXELXY_ADD_ARGB8888(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_ARGB8888)
+
+/*
+ * Define draw operators for general RGB
+ */
+
+#define DRAW_SETPIXEL_RGB \
+ DRAW_SETPIXEL(PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
+
+#define DRAW_SETPIXEL_BLEND_RGB \
+ DRAW_SETPIXEL_BLEND(RGB_FROM_PIXEL(*pixel, fmt, sr, sg, sb), \
+ PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
+
+#define DRAW_SETPIXEL_ADD_RGB \
+ DRAW_SETPIXEL_ADD(RGB_FROM_PIXEL(*pixel, fmt, sr, sg, sb), \
+ PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
+
+#define DRAW_SETPIXELXY2_RGB(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB)
+
+#define DRAW_SETPIXELXY4_RGB(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGB)
+
+#define DRAW_SETPIXELXY2_BLEND_RGB(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB)
+
+#define DRAW_SETPIXELXY4_BLEND_RGB(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGB)
+
+#define DRAW_SETPIXELXY2_ADD_RGB(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB)
+
+#define DRAW_SETPIXELXY4_ADD_RGB(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGB)
+
+
+/*
+ * Define draw operators for general RGBA
+ */
+
+#define DRAW_SETPIXEL_RGBA \
+ DRAW_SETPIXEL(PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_BLEND_RGBA \
+ DRAW_SETPIXEL_BLEND(RGBA_FROM_PIXEL(*pixel, fmt, sr, sg, sb, sa), \
+ PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_ADD_RGBA \
+ DRAW_SETPIXEL_ADD(RGBA_FROM_PIXEL(*pixel, fmt, sr, sg, sb, sa), \
+ PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
+
+#define DRAW_SETPIXELXY4_RGBA(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGBA)
+
+#define DRAW_SETPIXELXY4_BLEND_RGBA(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGBA)
+
+#define DRAW_SETPIXELXY4_ADD_RGBA(x, y) \
+ DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGBA)
+
+/*
+ * Define line drawing macro
+ */
+
+#define ABS(_x) ((_x) < 0 ? -(_x) : (_x))
+
+/* Horizontal line */
+#define HLINE(type, op, draw_end) \
+{ \
+ int length; \
+ int pitch = (dst->pitch / dst->format->BytesPerPixel); \
+ type *pixel; \
+ if (x1 <= x2) { \
+ pixel = (type *)dst->pixels + y1 * pitch + x1; \
+ length = draw_end ? (x2-x1+1) : (x2-x1); \
+ } else { \
+ pixel = (type *)dst->pixels + y1 * pitch + x2; \
+ if (!draw_end) { \
+ ++pixel; \
+ } \
+ length = draw_end ? (x1-x2+1) : (x1-x2); \
+ } \
+ while (length--) { \
+ op; \
+ ++pixel; \
+ } \
+}
+
+/* Vertical line */
+#define VLINE(type, op, draw_end) \
+{ \
+ int length; \
+ int pitch = (dst->pitch / dst->format->BytesPerPixel); \
+ type *pixel; \
+ if (y1 <= y2) { \
+ pixel = (type *)dst->pixels + y1 * pitch + x1; \
+ length = draw_end ? (y2-y1+1) : (y2-y1); \
+ } else { \
+ pixel = (type *)dst->pixels + y2 * pitch + x1; \
+ if (!draw_end) { \
+ pixel += pitch; \
+ } \
+ length = draw_end ? (y1-y2+1) : (y1-y2); \
+ } \
+ while (length--) { \
+ op; \
+ pixel += pitch; \
+ } \
+}
+
+/* Diagonal line */
+#define DLINE(type, op, draw_end) \
+{ \
+ int length; \
+ int pitch = (dst->pitch / dst->format->BytesPerPixel); \
+ type *pixel; \
+ if (y1 <= y2) { \
+ pixel = (type *)dst->pixels + y1 * pitch + x1; \
+ if (x1 <= x2) { \
+ ++pitch; \
+ } else { \
+ --pitch; \
+ } \
+ length = (y2-y1); \
+ } else { \
+ pixel = (type *)dst->pixels + y2 * pitch + x2; \
+ if (x2 <= x1) { \
+ ++pitch; \
+ } else { \
+ --pitch; \
+ } \
+ if (!draw_end) { \
+ pixel += pitch; \
+ } \
+ length = (y1-y2); \
+ } \
+ if (draw_end) { \
+ ++length; \
+ } \
+ while (length--) { \
+ op; \
+ pixel += pitch; \
+ } \
+}
+
+/* Bresenham's line algorithm */
+#define BLINE(x1, y1, x2, y2, op, draw_end) \
+{ \
+ int i, deltax, deltay, numpixels; \
+ int d, dinc1, dinc2; \
+ int x, xinc1, xinc2; \
+ int y, yinc1, yinc2; \
+ \
+ deltax = ABS(x2 - x1); \
+ deltay = ABS(y2 - y1); \
+ \
+ if (deltax >= deltay) { \
+ numpixels = deltax + 1; \
+ d = (2 * deltay) - deltax; \
+ dinc1 = deltay * 2; \
+ dinc2 = (deltay - deltax) * 2; \
+ xinc1 = 1; \
+ xinc2 = 1; \
+ yinc1 = 0; \
+ yinc2 = 1; \
+ } else { \
+ numpixels = deltay + 1; \
+ d = (2 * deltax) - deltay; \
+ dinc1 = deltax * 2; \
+ dinc2 = (deltax - deltay) * 2; \
+ xinc1 = 0; \
+ xinc2 = 1; \
+ yinc1 = 1; \
+ yinc2 = 1; \
+ } \
+ \
+ if (x1 > x2) { \
+ xinc1 = -xinc1; \
+ xinc2 = -xinc2; \
+ } \
+ if (y1 > y2) { \
+ yinc1 = -yinc1; \
+ yinc2 = -yinc2; \
+ } \
+ \
+ x = x1; \
+ y = y1; \
+ \
+ if (!draw_end) { \
+ --numpixels; \
+ } \
+ for (i = 0; i < numpixels; ++i) { \
+ op(x, y); \
+ if (d < 0) { \
+ d += dinc1; \
+ x += xinc1; \
+ y += yinc1; \
+ } else { \
+ d += dinc2; \
+ x += xinc2; \
+ y += yinc2; \
+ } \
+ } \
+}
+
+/* Xiaolin Wu's line algorithm, based on Michael Abrash's implementation */
+#define WULINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
+{ \
+ Uint16 ErrorAdj, ErrorAcc; \
+ Uint16 ErrorAccTemp, Weighting; \
+ int DeltaX, DeltaY, Temp, XDir; \
+ unsigned r, g, b, a, inva; \
+ \
+ /* Draw the initial pixel, which is always exactly intersected by \
+ the line and so needs no weighting */ \
+ opaque_op(x1, y1); \
+ \
+ /* Draw the final pixel, which is always exactly intersected by the line \
+ and so needs no weighting */ \
+ if (draw_end) { \
+ opaque_op(x2, y2); \
+ } \
+ \
+ /* Make sure the line runs top to bottom */ \
+ if (y1 > y2) { \
+ Temp = y1; y1 = y2; y2 = Temp; \
+ Temp = x1; x1 = x2; x2 = Temp; \
+ } \
+ DeltaY = y2 - y1; \
+ \
+ if ((DeltaX = x2 - x1) >= 0) { \
+ XDir = 1; \
+ } else { \
+ XDir = -1; \
+ DeltaX = -DeltaX; /* make DeltaX positive */ \
+ } \
+ \
+ /* line is not horizontal, diagonal, or vertical */ \
+ ErrorAcc = 0; /* initialize the line error accumulator to 0 */ \
+ \
+ /* Is this an X-major or Y-major line? */ \
+ if (DeltaY > DeltaX) { \
+ /* Y-major line; calculate 16-bit fixed-point fractional part of a \
+ pixel that X advances each time Y advances 1 pixel, truncating the \
+ result so that we won't overrun the endpoint along the X axis */ \
+ ErrorAdj = ((unsigned long) DeltaX << 16) / (unsigned long) DeltaY; \
+ /* Draw all pixels other than the first and last */ \
+ while (--DeltaY) { \
+ ErrorAccTemp = ErrorAcc; /* remember currrent accumulated error */ \
+ ErrorAcc += ErrorAdj; /* calculate error for next pixel */ \
+ if (ErrorAcc <= ErrorAccTemp) { \
+ /* The error accumulator turned over, so advance the X coord */ \
+ x1 += XDir; \
+ } \
+ y1++; /* Y-major, so always advance Y */ \
+ /* The IntensityBits most significant bits of ErrorAcc give us the \
+ intensity weighting for this pixel, and the complement of the \
+ weighting for the paired pixel */ \
+ Weighting = ErrorAcc >> 8; \
+ { \
+ a = DRAW_MUL(_a, (Weighting ^ 255)); \
+ r = DRAW_MUL(_r, a); \
+ g = DRAW_MUL(_g, a); \
+ b = DRAW_MUL(_b, a); \
+ inva = (a ^ 0xFF); \
+ blend_op(x1, y1); \
+ } \
+ { \
+ a = DRAW_MUL(_a, Weighting); \
+ r = DRAW_MUL(_r, a); \
+ g = DRAW_MUL(_g, a); \
+ b = DRAW_MUL(_b, a); \
+ inva = (a ^ 0xFF); \
+ blend_op(x1 + XDir, y1); \
+ } \
+ } \
+ } else { \
+ /* X-major line; calculate 16-bit fixed-point fractional part of a \
+ pixel that Y advances each time X advances 1 pixel, truncating the \
+ result to avoid overrunning the endpoint along the X axis */ \
+ ErrorAdj = ((unsigned long) DeltaY << 16) / (unsigned long) DeltaX; \
+ /* Draw all pixels other than the first and last */ \
+ while (--DeltaX) { \
+ ErrorAccTemp = ErrorAcc; /* remember currrent accumulated error */ \
+ ErrorAcc += ErrorAdj; /* calculate error for next pixel */ \
+ if (ErrorAcc <= ErrorAccTemp) { \
+ /* The error accumulator turned over, so advance the Y coord */ \
+ y1++; \
+ } \
+ x1 += XDir; /* X-major, so always advance X */ \
+ /* The IntensityBits most significant bits of ErrorAcc give us the \
+ intensity weighting for this pixel, and the complement of the \
+ weighting for the paired pixel */ \
+ Weighting = ErrorAcc >> 8; \
+ { \
+ a = DRAW_MUL(_a, (Weighting ^ 255)); \
+ r = DRAW_MUL(_r, a); \
+ g = DRAW_MUL(_g, a); \
+ b = DRAW_MUL(_b, a); \
+ inva = (a ^ 0xFF); \
+ blend_op(x1, y1); \
+ } \
+ { \
+ a = DRAW_MUL(_a, Weighting); \
+ r = DRAW_MUL(_r, a); \
+ g = DRAW_MUL(_g, a); \
+ b = DRAW_MUL(_b, a); \
+ inva = (a ^ 0xFF); \
+ blend_op(x1, y1 + 1); \
+ } \
+ } \
+ } \
+}
+
+#ifdef AA_LINES
+#define AALINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
+ WULINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end)
+#else
+#define AALINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
+ BLINE(x1, y1, x2, y2, opaque_op, draw_end)
+#endif
+
+/*
+ * Define fill rect macro
+ */
+
+#define FILLRECT(type, op) \
+do { \
+ int width = rect->w; \
+ int height = rect->h; \
+ int pitch = (dst->pitch / dst->format->BytesPerPixel); \
+ int skip = pitch - width; \
+ type *pixel = (type *)dst->pixels + rect->y * pitch + rect->x; \
+ while (height--) { \
+ { int n = (width+3)/4; \
+ switch (width & 3) { \
+ case 0: do { op; pixel++; \
+ case 3: op; pixel++; \
+ case 2: op; pixel++; \
+ case 1: op; pixel++; \
+ } while ( --n > 0 ); \
+ } \
+ } \
+ pixel += skip; \
+ } \
+} while (0)
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_drawline.c Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,210 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2010 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"
+
+#include "SDL_draw.h"
+#include "SDL_drawline.h"
+
+
+static void
+SDL_DrawLine1(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color,
+ SDL_bool draw_end)
+{
+ if (y1 == y2) {
+ //HLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
+ int length;
+ int pitch = (dst->pitch / dst->format->BytesPerPixel);
+ Uint8 *pixel;
+ if (x1 <= x2) {
+ pixel = (Uint8 *)dst->pixels + y1 * pitch + x1;
+ length = draw_end ? (x2-x1+1) : (x2-x1);
+ } else {
+ pixel = (Uint8 *)dst->pixels + y1 * pitch + x2;
+ if (!draw_end) {
+ ++pixel;
+ }
+ length = draw_end ? (x1-x2+1) : (x1-x2);
+ }
+ SDL_memset(pixel, color, length);
+ } else if (x1 == x2) {
+ VLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
+ } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+ DLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
+ } else {
+ BLINE(x1, y1, x2, y2, DRAW_FASTSETPIXELXY1, draw_end);
+ }
+}
+
+static void
+SDL_DrawLine2(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color,
+ SDL_bool draw_end)
+{
+ if (y1 == y2) {
+ HLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
+ } else if (x1 == x2) {
+ VLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
+ } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+ DLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
+ } else {
+ Uint8 _r, _g, _b, _a;
+ const SDL_PixelFormat * fmt = dst->format;
+ SDL_GetRGBA(color, fmt, &_r, &_g, &_b, &_a);
+ if (fmt->Rmask == 0x7C00) {
+ AALINE(x1, y1, x2, y2,
+ DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY_BLEND_RGB555,
+ draw_end);
+ } else if (fmt->Rmask == 0xF800) {
+ AALINE(x1, y1, x2, y2,
+ DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY_BLEND_RGB565,
+ draw_end);
+ } else {
+ AALINE(x1, y1, x2, y2,
+ DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY2_BLEND_RGB,
+ draw_end);
+ }
+ }
+}
+
+static void
+SDL_DrawLine4(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color,
+ SDL_bool draw_end)
+{
+ if (y1 == y2) {
+ HLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
+ } else if (x1 == x2) {
+ VLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
+ } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+ DLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
+ } else {
+ Uint8 _r, _g, _b, _a;
+ const SDL_PixelFormat * fmt = dst->format;
+ SDL_GetRGBA(color, fmt, &_r, &_g, &_b, &_a);
+ if (fmt->Rmask == 0x00FF0000) {
+ if (!fmt->Amask) {
+ AALINE(x1, y1, x2, y2,
+ DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY_BLEND_RGB888,
+ draw_end);
+ } else {
+ AALINE(x1, y1, x2, y2,
+ DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY_BLEND_ARGB8888,
+ draw_end);
+ }
+ } else {
+ AALINE(x1, y1, x2, y2,
+ DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY4_BLEND_RGB,
+ draw_end);
+ }
+ }
+}
+
+typedef void (*DrawLineFunc) (SDL_Surface * dst,
+ int x1, int y1, int x2, int y2,
+ Uint32 color, SDL_bool draw_end);
+
+static DrawLineFunc
+SDL_CalculateDrawLineFunc(const SDL_PixelFormat * fmt)
+{
+ switch (fmt->BytesPerPixel) {
+ case 1:
+ if (fmt->BitsPerPixel < 8) {
+ break;
+ }
+ return SDL_DrawLine1;
+ case 2:
+ return SDL_DrawLine2;
+ case 4:
+ return SDL_DrawLine4;
+ }
+ return NULL;
+}
+
+int
+SDL_DrawLine(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color)
+{
+ DrawLineFunc func;
+
+ if (!dst) {
+ SDL_SetError("SDL_DrawLine(): Passed NULL destination surface");
+ return -1;
+ }
+
+ func = SDL_CalculateDrawLineFunc(dst->format);
+ if (!func) {
+ SDL_SetError("SDL_DrawLine(): Unsupported surface format");
+ return -1;
+ }
+
+ /* Perform clipping */
+ /* FIXME: We don't actually want to clip, as it may change line slope */
+ if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
+ return 0;
+ }
+
+ func(dst, x1, y1, x2, y2, color, SDL_TRUE);
+ return 0;
+}
+
+int
+SDL_DrawLines(SDL_Surface * dst, const SDL_Point * points, int count,
+ Uint32 color)
+{
+ int i;
+ int x1, y1;
+ int x2, y2;
+ SDL_bool draw_end;
+ DrawLineFunc func;
+
+ if (!dst) {
+ SDL_SetError("SDL_DrawLines(): Passed NULL destination surface");
+ return -1;
+ }
+
+ func = SDL_CalculateDrawLineFunc(dst->format);
+ if (!func) {
+ SDL_SetError("SDL_DrawLines(): Unsupported surface format");
+ return -1;
+ }
+
+ for (i = 1; i < count; ++i) {
+ x1 = points[i-1].x;
+ y1 = points[i-1].y;
+ x2 = points[i].x;
+ y2 = points[i].y;
+
+ /* Perform clipping */
+ /* FIXME: We don't actually want to clip, as it may change line slope */
+ if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
+ continue;
+ }
+
+ /* Draw the end if it was clipped */
+ draw_end = (x2 != points[i].x || y2 != points[i].y);
+
+ func(dst, x1, y1, x2, y2, color, draw_end);
+ }
+ if (points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
+ SDL_DrawPoint(dst, points[count-1].x, points[count-1].y, color);
+ }
+ return 0;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_drawline.h Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,28 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2010 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"
+
+
+extern int SDL_DrawLine(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color);
+extern int SDL_DrawLines(SDL_Surface * dst, const SDL_Point * points, int count, Uint32 color);
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_drawpoint.c Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,117 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2010 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"
+
+#include "SDL_draw.h"
+#include "SDL_drawpoint.h"
+
+
+int
+SDL_DrawPoint(SDL_Surface * dst, int x, int y, Uint32 color)
+{
+ if (!dst) {
+ SDL_SetError("Passed NULL destination surface");
+ return -1;
+ }
+
+ /* This function doesn't work on surfaces < 8 bpp */
+ if (dst->format->BitsPerPixel < 8) {
+ SDL_SetError("SDL_DrawPoint(): Unsupported surface format");
+ return -1;
+ }
+
+ /* Perform clipping */
+ if (x < dst->clip_rect.x || y < dst->clip_rect.y ||
+ x >= (dst->clip_rect.x + dst->clip_rect.w) ||
+ y >= (dst->clip_rect.y + dst->clip_rect.h)) {
+ return 0;
+ }
+
+ switch (dst->format->BytesPerPixel) {
+ case 1:
+ DRAW_FASTSETPIXELXY1(x, y);
+ break;
+ case 2:
+ DRAW_FASTSETPIXELXY2(x, y);
+ break;
+ case 3:
+ SDL_Unsupported();
+ return -1;
+ case 4:
+ DRAW_FASTSETPIXELXY4(x, y);
+ break;
+ }
+ return 0;
+}
+
+int
+SDL_DrawPoints(SDL_Surface * dst, const SDL_Point * points, int count,
+ Uint32 color)
+{
+ int minx, miny;
+ int maxx, maxy;
+ int i;
+ int x, y;
+
+ if (!dst) {
+ SDL_SetError("Passed NULL destination surface");
+ return -1;
+ }
+
+ /* This function doesn't work on surfaces < 8 bpp */
+ if (dst->format->BitsPerPixel < 8) {
+ SDL_SetError("SDL_DrawPoints(): Unsupported surface format");
+ return -1;
+ }
+
+ minx = dst->clip_rect.x;
+ maxx = dst->clip_rect.x + dst->clip_rect.w - 1;
+ miny = dst->clip_rect.y;
+ maxy = dst->clip_rect.y + dst->clip_rect.h - 1;
+
+ for (i = 0; i < count; ++i) {
+ x = points[i].x;
+ y = points[i].y;
+
+ if (x < minx || x > maxx || y < miny || y > maxy) {
+ continue;
+ }
+
+ switch (dst->format->BytesPerPixel) {
+ case 1:
+ DRAW_FASTSETPIXELXY1(x, y);
+ break;
+ case 2:
+ DRAW_FASTSETPIXELXY2(x, y);
+ break;
+ case 3:
+ SDL_Unsupported();
+ return -1;
+ case 4:
+ DRAW_FASTSETPIXELXY4(x, y);
+ break;
+ }
+ }
+ return 0;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_drawpoint.h Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,28 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2010 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"
+
+
+extern int SDL_DrawPoint(SDL_Surface * dst, int x, int y, Uint32 color);
+extern int SDL_DrawPoints(SDL_Surface * dst, const SDL_Point * points, int count, Uint32 color);
+
+/* vi: set ts=4 sw=4 expandtab: */
--- a/src/render/software/SDL_renderer_sw.c Thu Feb 03 02:42:50 2011 -0800
+++ b/src/render/software/SDL_renderer_sw.c Thu Feb 03 02:45:29 2011 -0800
@@ -24,6 +24,13 @@
#include "../SDL_sysrender.h"
#include "../../video/SDL_pixels_c.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"
+
/* SDL surface based renderer implementation */
--- a/src/video/SDL_alphamult.c Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,60 +0,0 @@
-/*
- SDL - Simple DirectMedia Layer
- Copyright (C) 1997-2010 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"
-
-#include "SDL_blit.h"
-#include "SDL_alphamult.h"
-
-/* Functions to pre-multiply the alpha channel into the color channels */
-
-#define DEFINE_PREMULTIPLY_FUNC(fmt) \
-void \
-SDL_PreMultiplyAlpha##fmt(int w, int h, Uint32 *pixels, int pitch) \
-{ \
- pitch /= 4; \
- while (h--) { \
- int n; \
- Uint32 *row = pixels; \
- Uint32 pixel; \
- unsigned r, g, b, a; \
- \
- for (n = w; n--; ) { \
- pixel = *row; \
- RGBA_FROM_##fmt(pixel, r, g, b, a); \
- r = (r * a) / 255; \
- g = (g * a) / 255; \
- b = (b * a) / 255; \
- fmt##_FROM_RGBA(*row, r, g, b, a); \
- ++row; \
- } \
- pixels += pitch; \
- } \
-}
-
-/* *INDENT-OFF* */
-DEFINE_PREMULTIPLY_FUNC(ARGB8888)
-DEFINE_PREMULTIPLY_FUNC(RGBA8888)
-DEFINE_PREMULTIPLY_FUNC(ABGR8888)
-DEFINE_PREMULTIPLY_FUNC(BGRA8888)
-/* *INDENT-ON* */
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_alphamult.h Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,38 +0,0 @@
-/*
- SDL - Simple DirectMedia Layer
- Copyright (C) 1997-2010 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
-*/
-
-/* Functions to pre-multiply the alpha channel into the color channels */
-
-#define DEFINE_PREMULTIPLY_FUNC(fmt) \
-void \
-SDL_PreMultiplyAlpha##fmt(int w, int h, Uint32 *pixels, int pitch);
-
-/* *INDENT-OFF* */
-DEFINE_PREMULTIPLY_FUNC(ARGB8888)
-DEFINE_PREMULTIPLY_FUNC(RGBA8888)
-DEFINE_PREMULTIPLY_FUNC(ABGR8888)
-DEFINE_PREMULTIPLY_FUNC(BGRA8888)
-/* *INDENT-ON* */
-
-#undef DEFINE_PREMULTIPLY_FUNC
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_blendfillrect.c Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,326 +0,0 @@
-/*
- SDL - Simple DirectMedia Layer
- Copyright (C) 1997-2010 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"
-
-#include "SDL_video.h"
-#include "SDL_draw.h"
-
-static int
-SDL_BlendFillRect_RGB555(SDL_Surface * dst, const SDL_Rect * rect,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
- unsigned inva = 0xff - a;
-
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB555);
- break;
- case SDL_BLENDMODE_ADD:
- FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB555);
- break;
- default:
- FILLRECT(Uint16, DRAW_SETPIXEL_RGB555);
- break;
- }
- return 0;
-}
-
-static int
-SDL_BlendFillRect_RGB565(SDL_Surface * dst, const SDL_Rect * rect,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
- unsigned inva = 0xff - a;
-
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB565);
- break;
- case SDL_BLENDMODE_ADD:
- FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB565);
- break;
- default:
- FILLRECT(Uint16, DRAW_SETPIXEL_RGB565);
- break;
- }
- return 0;
-}
-
-static int
-SDL_BlendFillRect_RGB888(SDL_Surface * dst, const SDL_Rect * rect,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
- unsigned inva = 0xff - a;
-
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGB888);
- break;
- case SDL_BLENDMODE_ADD:
- FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGB888);
- break;
- default:
- FILLRECT(Uint32, DRAW_SETPIXEL_RGB888);
- break;
- }
- return 0;
-}
-
-static int
-SDL_BlendFillRect_ARGB8888(SDL_Surface * dst, const SDL_Rect * rect,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
- unsigned inva = 0xff - a;
-
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888);
- break;
- case SDL_BLENDMODE_ADD:
- FILLRECT(Uint32, DRAW_SETPIXEL_ADD_ARGB8888);
- break;
- default:
- FILLRECT(Uint32, DRAW_SETPIXEL_ARGB8888);
- break;
- }
- return 0;
-}
-
-static int
-SDL_BlendFillRect_RGB(SDL_Surface * dst, const SDL_Rect * rect,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
- SDL_PixelFormat *fmt = dst->format;
- unsigned inva = 0xff - a;
-
- switch (fmt->BytesPerPixel) {
- case 2:
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB);
- break;
- case SDL_BLENDMODE_ADD:
- FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB);
- break;
- default:
- FILLRECT(Uint16, DRAW_SETPIXEL_RGB);
- break;
- }
- return 0;
- case 4:
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGB);
- break;
- case SDL_BLENDMODE_ADD:
- FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGB);
- break;
- default:
- FILLRECT(Uint32, DRAW_SETPIXEL_RGB);
- break;
- }
- return 0;
- default:
- SDL_Unsupported();
- return -1;
- }
-}
-
-static int
-SDL_BlendFillRect_RGBA(SDL_Surface * dst, const SDL_Rect * rect,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
- SDL_PixelFormat *fmt = dst->format;
- unsigned inva = 0xff - a;
-
- switch (fmt->BytesPerPixel) {
- case 4:
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGBA);
- break;
- case SDL_BLENDMODE_ADD:
- FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGBA);
- break;
- default:
- FILLRECT(Uint32, DRAW_SETPIXEL_RGBA);
- break;
- }
- return 0;
- default:
- SDL_Unsupported();
- return -1;
- }
-}
-
-int
-SDL_BlendFillRect(SDL_Surface * dst, const SDL_Rect * rect,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
- SDL_Rect clipped;
-
- if (!dst) {
- SDL_SetError("Passed NULL destination surface");
- return -1;
- }
-
- /* This function doesn't work on surfaces < 8 bpp */
- if (dst->format->BitsPerPixel < 8) {
- SDL_SetError("SDL_BlendFillRect(): Unsupported surface format");
- return -1;
- }
-
- /* If 'rect' == NULL, then fill the whole surface */
- if (rect) {
- /* Perform clipping */
- if (!SDL_IntersectRect(rect, &dst->clip_rect, &clipped)) {
- return 0;
- }
- rect = &clipped;
- } else {
- rect = &dst->clip_rect;
- }
-
- if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
- r = DRAW_MUL(r, a);
- g = DRAW_MUL(g, a);
- b = DRAW_MUL(b, a);
- }
-
- switch (dst->format->BitsPerPixel) {
- case 15:
- switch (dst->format->Rmask) {
- case 0x7C00:
- return SDL_BlendFillRect_RGB555(dst, rect, blendMode, r, g, b, a);
- }
- break;
- case 16:
- switch (dst->format->Rmask) {
- case 0xF800:
- return SDL_BlendFillRect_RGB565(dst, rect, blendMode, r, g, b, a);
- }
- break;
- case 32:
- switch (dst->format->Rmask) {
- case 0x00FF0000:
- if (!dst->format->Amask) {
- return SDL_BlendFillRect_RGB888(dst, rect, blendMode, r, g, b, a);
- } else {
- return SDL_BlendFillRect_ARGB8888(dst, rect, blendMode, r, g, b, a);
- }
- break;
- }
- break;
- default:
- break;
- }
-
- if (!dst->format->Amask) {
- return SDL_BlendFillRect_RGB(dst, rect, blendMode, r, g, b, a);
- } else {
- return SDL_BlendFillRect_RGBA(dst, rect, blendMode, r, g, b, a);
- }
-}
-
-int
-SDL_BlendFillRects(SDL_Surface * dst, const SDL_Rect ** rects, int count,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
- SDL_Rect clipped;
- int i;
- int (*func)(SDL_Surface * dst, const SDL_Rect * rect,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a) = NULL;
- int status = 0;
-
- if (!dst) {
- SDL_SetError("Passed NULL destination surface");
- return -1;
- }
-
- /* This function doesn't work on surfaces < 8 bpp */
- if (dst->format->BitsPerPixel < 8) {
- SDL_SetError("SDL_BlendFillRects(): Unsupported surface format");
- return -1;
- }
-
- if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
- r = DRAW_MUL(r, a);
- g = DRAW_MUL(g, a);
- b = DRAW_MUL(b, a);
- }
-
- /* FIXME: Does this function pointer slow things down significantly? */
- switch (dst->format->BitsPerPixel) {
- case 15:
- switch (dst->format->Rmask) {
- case 0x7C00:
- func = SDL_BlendFillRect_RGB555;
- }
- break;
- case 16:
- switch (dst->format->Rmask) {
- case 0xF800:
- func = SDL_BlendFillRect_RGB565;
- }
- break;
- case 32:
- switch (dst->format->Rmask) {
- case 0x00FF0000:
- if (!dst->format->Amask) {
- func = SDL_BlendFillRect_RGB888;
- } else {
- func = SDL_BlendFillRect_ARGB8888;
- }
- break;
- }
- break;
- default:
- break;
- }
-
- if (!func) {
- if (!dst->format->Amask) {
- func = SDL_BlendFillRect_RGB;
- } else {
- func = SDL_BlendFillRect_RGBA;
- }
- }
-
- for (i = 0; i < count; ++i) {
- const SDL_Rect * rect = rects[i];
-
- /* If 'rect' == NULL, then fill the whole surface */
- if (rect) {
- /* Perform clipping */
- if (!SDL_IntersectRect(rect, &dst->clip_rect, &clipped)) {
- continue;
- }
- rect = &clipped;
- } else {
- rect = &dst->clip_rect;
- }
-
- status = func(dst, rect, blendMode, r, g, b, a);
- }
- return status;
-}
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_blendline.c Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,682 +0,0 @@
-/*
- SDL - Simple DirectMedia Layer
- Copyright (C) 1997-2010 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"
-
-#include "SDL_draw.h"
-
-
-static void
-SDL_BlendLine_RGB2(SDL_Surface * dst, int x1, int y1, int x2, int y2,
- SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
- SDL_bool draw_end)
-{
- const SDL_PixelFormat *fmt = dst->format;
- unsigned r, g, b, a, inva;
-
- if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
- r = DRAW_MUL(_r, _a);
- g = DRAW_MUL(_g, _a);
- b = DRAW_MUL(_b, _a);
- a = _a;
- } else {
- r = _r;
- g = _g;
- b = _b;
- a = _a;
- }
- inva = (a ^ 0xff);
-
- if (y1 == y2) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
- break;
- default:
- HLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
- break;
- }
- } else if (x1 == x2) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
- break;
- default:
- VLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
- break;
- }
- } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
- break;
- default:
- DLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
- break;
- }
- } else {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY2_BLEND_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
- draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY2_ADD_RGB, DRAW_SETPIXELXY2_ADD_RGB,
- draw_end);
- break;
- default:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY2_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
- draw_end);
- break;
- }
- }
-}
-
-static void
-SDL_BlendLine_RGB555(SDL_Surface * dst, int x1, int y1, int x2, int y2,
- SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
- SDL_bool draw_end)
-{
- const SDL_PixelFormat *fmt = dst->format;
- unsigned r, g, b, a, inva;
-
- if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
- r = DRAW_MUL(_r, _a);
- g = DRAW_MUL(_g, _a);
- b = DRAW_MUL(_b, _a);
- a = _a;
- } else {
- r = _r;
- g = _g;
- b = _b;
- a = _a;
- }
- inva = (a ^ 0xff);
-
- if (y1 == y2) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
- break;
- default:
- HLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
- break;
- }
- } else if (x1 == x2) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
- break;
- default:
- VLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
- break;
- }
- } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
- break;
- default:
- DLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
- break;
- }
- } else {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY_BLEND_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
- draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY_ADD_RGB555, DRAW_SETPIXELXY_ADD_RGB555,
- draw_end);
- break;
- default:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
- draw_end);
- break;
- }
- }
-}
-
-static void
-SDL_BlendLine_RGB565(SDL_Surface * dst, int x1, int y1, int x2, int y2,
- SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
- SDL_bool draw_end)
-{
- const SDL_PixelFormat *fmt = dst->format;
- unsigned r, g, b, a, inva;
-
- if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
- r = DRAW_MUL(_r, _a);
- g = DRAW_MUL(_g, _a);
- b = DRAW_MUL(_b, _a);
- a = _a;
- } else {
- r = _r;
- g = _g;
- b = _b;
- a = _a;
- }
- inva = (a ^ 0xff);
-
- if (y1 == y2) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
- break;
- default:
- HLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
- break;
- }
- } else if (x1 == x2) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
- break;
- default:
- VLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
- break;
- }
- } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
- break;
- default:
- DLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
- break;
- }
- } else {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY_BLEND_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
- draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY_ADD_RGB565, DRAW_SETPIXELXY_ADD_RGB565,
- draw_end);
- break;
- default:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
- draw_end);
- break;
- }
- }
-}
-
-static void
-SDL_BlendLine_RGB4(SDL_Surface * dst, int x1, int y1, int x2, int y2,
- SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
- SDL_bool draw_end)
-{
- const SDL_PixelFormat *fmt = dst->format;
- unsigned r, g, b, a, inva;
-
- if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
- r = DRAW_MUL(_r, _a);
- g = DRAW_MUL(_g, _a);
- b = DRAW_MUL(_b, _a);
- a = _a;
- } else {
- r = _r;
- g = _g;
- b = _b;
- a = _a;
- }
- inva = (a ^ 0xff);
-
- if (y1 == y2) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
- break;
- default:
- HLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
- break;
- }
- } else if (x1 == x2) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
- break;
- default:
- VLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
- break;
- }
- } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
- break;
- default:
- DLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
- break;
- }
- } else {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY4_BLEND_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
- draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY4_ADD_RGB, DRAW_SETPIXELXY4_ADD_RGB,
- draw_end);
- break;
- default:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY4_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
- draw_end);
- break;
- }
- }
-}
-
-static void
-SDL_BlendLine_RGBA4(SDL_Surface * dst, int x1, int y1, int x2, int y2,
- SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
- SDL_bool draw_end)
-{
- const SDL_PixelFormat *fmt = dst->format;
- unsigned r, g, b, a, inva;
-
- if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
- r = DRAW_MUL(_r, _a);
- g = DRAW_MUL(_g, _a);
- b = DRAW_MUL(_b, _a);
- a = _a;
- } else {
- r = _r;
- g = _g;
- b = _b;
- a = _a;
- }
- inva = (a ^ 0xff);
-
- if (y1 == y2) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- HLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
- break;
- default:
- HLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
- break;
- }
- } else if (x1 == x2) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- VLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
- break;
- default:
- VLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
- break;
- }
- } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- DLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
- break;
- default:
- DLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
- break;
- }
- } else {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY4_BLEND_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
- draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY4_ADD_RGBA, DRAW_SETPIXELXY4_ADD_RGBA,
- draw_end);
- break;
- default:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY4_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
- draw_end);
- break;
- }
- }
-}
-
-static void
-SDL_BlendLine_RGB888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
- SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
- SDL_bool draw_end)
-{
- const SDL_PixelFormat *fmt = dst->format;
- unsigned r, g, b, a, inva;
-
- if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
- r = DRAW_MUL(_r, _a);
- g = DRAW_MUL(_g, _a);
- b = DRAW_MUL(_b, _a);
- a = _a;
- } else {
- r = _r;
- g = _g;
- b = _b;
- a = _a;
- }
- inva = (a ^ 0xff);
-
- if (y1 == y2) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
- break;
- default:
- HLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
- break;
- }
- } else if (x1 == x2) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
- break;
- default:
- VLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
- break;
- }
- } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
- break;
- default:
- DLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
- break;
- }
- } else {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY_BLEND_RGB888, DRAW_SETPIXELXY_BLEND_RGB888,
- draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY_ADD_RGB888, DRAW_SETPIXELXY_ADD_RGB888,
- draw_end);
- break;
- default:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY_RGB888, DRAW_SETPIXELXY_BLEND_RGB888,
- draw_end);
- break;
- }
- }
-}
-
-static void
-SDL_BlendLine_ARGB8888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
- SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
- SDL_bool draw_end)
-{
- const SDL_PixelFormat *fmt = dst->format;
- unsigned r, g, b, a, inva;
-
- if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
- r = DRAW_MUL(_r, _a);
- g = DRAW_MUL(_g, _a);
- b = DRAW_MUL(_b, _a);
- a = _a;
- } else {
- r = _r;
- g = _g;
- b = _b;
- a = _a;
- }
- inva = (a ^ 0xff);
-
- if (y1 == y2) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- HLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- HLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
- break;
- default:
- HLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
- break;
- }
- } else if (x1 == x2) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- VLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- VLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
- break;
- default:
- VLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
- break;
- }
- } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- DLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- DLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
- break;
- default:
- DLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
- break;
- }
- } else {
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY_BLEND_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
- draw_end);
- break;
- case SDL_BLENDMODE_ADD:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY_ADD_ARGB8888, DRAW_SETPIXELXY_ADD_ARGB8888,
- draw_end);
- break;
- default:
- AALINE(x1, y1, x2, y2,
- DRAW_SETPIXELXY_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
- draw_end);
- break;
- }
- }
-}
-
-typedef void (*BlendLineFunc) (SDL_Surface * dst,
- int x1, int y1, int x2, int y2,
- SDL_BlendMode blendMode,
- Uint8 r, Uint8 g, Uint8 b, Uint8 a,
- SDL_bool draw_end);
-
-static BlendLineFunc
-SDL_CalculateBlendLineFunc(const SDL_PixelFormat * fmt)
-{
- switch (fmt->BytesPerPixel) {
- case 2:
- if (fmt->Rmask == 0x7C00) {
- return SDL_BlendLine_RGB555;
- } else if (fmt->Rmask == 0xF800) {
- return SDL_BlendLine_RGB565;
- } else {
- return SDL_BlendLine_RGB2;
- }
- break;
- case 4:
- if (fmt->Rmask == 0x00FF0000) {
- if (fmt->Amask) {
- return SDL_BlendLine_ARGB8888;
- } else {
- return SDL_BlendLine_RGB888;
- }
- } else {
- if (fmt->Amask) {
- return SDL_BlendLine_RGBA4;
- } else {
- return SDL_BlendLine_RGB4;
- }
- }
- }
- return NULL;
-}
-
-int
-SDL_BlendLine(SDL_Surface * dst, int x1, int y1, int x2, int y2,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
- BlendLineFunc func;
-
- if (!dst) {
- SDL_SetError("SDL_BlendLine(): Passed NULL destination surface");
- return -1;
- }
-
- func = SDL_CalculateBlendLineFunc(dst->format);
- if (!func) {
- SDL_SetError("SDL_BlendLine(): Unsupported surface format");
- return -1;
- }
-
- /* Perform clipping */
- /* FIXME: We don't actually want to clip, as it may change line slope */
- if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
- return 0;
- }
-
- func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, SDL_TRUE);
- return 0;
-}
-
-int
-SDL_BlendLines(SDL_Surface * dst, const SDL_Point * points, int count,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
- int i;
- int x1, y1;
- int x2, y2;
- SDL_bool draw_end;
- BlendLineFunc func;
-
- if (!dst) {
- SDL_SetError("SDL_BlendLines(): Passed NULL destination surface");
- return -1;
- }
-
- func = SDL_CalculateBlendLineFunc(dst->format);
- if (!func) {
- SDL_SetError("SDL_BlendLines(): Unsupported surface format");
- return -1;
- }
-
- for (i = 1; i < count; ++i) {
- x1 = points[i-1].x;
- y1 = points[i-1].y;
- x2 = points[i].x;
- y2 = points[i].y;
-
- /* Perform clipping */
- /* FIXME: We don't actually want to clip, as it may change line slope */
- if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
- continue;
- }
-
- /* Draw the end if it was clipped */
- draw_end = (x2 != points[i].x || y2 != points[i].y);
-
- func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, draw_end);
- }
- if (points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
- SDL_BlendPoint(dst, points[count-1].x, points[count-1].y,
- blendMode, r, g, b, a);
- }
- return 0;
-}
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_blendpoint.c Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,323 +0,0 @@
-/*
- SDL - Simple DirectMedia Layer
- Copyright (C) 1997-2010 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"
-
-#include "SDL_draw.h"
-
-static int
-SDL_BlendPoint_RGB555(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
- Uint8 g, Uint8 b, Uint8 a)
-{
- unsigned inva = 0xff - a;
-
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- DRAW_SETPIXELXY_BLEND_RGB555(x, y);
- break;
- case SDL_BLENDMODE_ADD:
- DRAW_SETPIXELXY_ADD_RGB555(x, y);
- break;
- default:
- DRAW_SETPIXELXY_RGB555(x, y);
- break;
- }
- return 0;
-}
-
-static int
-SDL_BlendPoint_RGB565(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
- Uint8 g, Uint8 b, Uint8 a)
-{
- unsigned inva = 0xff - a;
-
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- DRAW_SETPIXELXY_BLEND_RGB565(x, y);
- break;
- case SDL_BLENDMODE_ADD:
- DRAW_SETPIXELXY_ADD_RGB565(x, y);
- break;
- default:
- DRAW_SETPIXELXY_RGB565(x, y);
- break;
- }
- return 0;
-}
-
-static int
-SDL_BlendPoint_RGB888(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
- Uint8 g, Uint8 b, Uint8 a)
-{
- unsigned inva = 0xff - a;
-
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- DRAW_SETPIXELXY_BLEND_RGB888(x, y);
- break;
- case SDL_BLENDMODE_ADD:
- DRAW_SETPIXELXY_ADD_RGB888(x, y);
- break;
- default:
- DRAW_SETPIXELXY_RGB888(x, y);
- break;
- }
- return 0;
-}
-
-static int
-SDL_BlendPoint_ARGB8888(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode,
- Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
- unsigned inva = 0xff - a;
-
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- DRAW_SETPIXELXY_BLEND_ARGB8888(x, y);
- break;
- case SDL_BLENDMODE_ADD:
- DRAW_SETPIXELXY_ADD_ARGB8888(x, y);
- break;
- default:
- DRAW_SETPIXELXY_ARGB8888(x, y);
- break;
- }
- return 0;
-}
-
-static int
-SDL_BlendPoint_RGB(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
- Uint8 g, Uint8 b, Uint8 a)
-{
- SDL_PixelFormat *fmt = dst->format;
- unsigned inva = 0xff - a;
-
- switch (fmt->BytesPerPixel) {
- case 2:
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- DRAW_SETPIXELXY2_BLEND_RGB(x, y);
- break;
- case SDL_BLENDMODE_ADD:
- DRAW_SETPIXELXY2_ADD_RGB(x, y);
- break;
- default:
- DRAW_SETPIXELXY2_RGB(x, y);
- break;
- }
- return 0;
- case 4:
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- DRAW_SETPIXELXY4_BLEND_RGB(x, y);
- break;
- case SDL_BLENDMODE_ADD:
- DRAW_SETPIXELXY4_ADD_RGB(x, y);
- break;
- default:
- DRAW_SETPIXELXY4_RGB(x, y);
- break;
- }
- return 0;
- default:
- SDL_Unsupported();
- return -1;
- }
-}
-
-static int
-SDL_BlendPoint_RGBA(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
- Uint8 g, Uint8 b, Uint8 a)
-{
- SDL_PixelFormat *fmt = dst->format;
- unsigned inva = 0xff - a;
-
- switch (fmt->BytesPerPixel) {
- case 4:
- switch (blendMode) {
- case SDL_BLENDMODE_BLEND:
- DRAW_SETPIXELXY4_BLEND_RGBA(x, y);
- break;
- case SDL_BLENDMODE_ADD:
- DRAW_SETPIXELXY4_ADD_RGBA(x, y);
- break;
- default:
- DRAW_SETPIXELXY4_RGBA(x, y);
- break;
- }
- return 0;
- default:
- SDL_Unsupported();
- return -1;
- }
-}
-
-int
-SDL_BlendPoint(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
- Uint8 g, Uint8 b, Uint8 a)
-{
- if (!dst) {
- SDL_SetError("Passed NULL destination surface");
- return -1;
- }
-
- /* This function doesn't work on surfaces < 8 bpp */
- if (dst->format->BitsPerPixel < 8) {
- SDL_SetError("SDL_BlendPoint(): Unsupported surface format");
- return -1;
- }
-
- /* Perform clipping */
- if (x < dst->clip_rect.x || y < dst->clip_rect.y ||
- x >= (dst->clip_rect.x + dst->clip_rect.w) ||
- y >= (dst->clip_rect.y + dst->clip_rect.h)) {
- return 0;
- }
-
- if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
- r = DRAW_MUL(r, a);
- g = DRAW_MUL(g, a);
- b = DRAW_MUL(b, a);
- }
-
- switch (dst->format->BitsPerPixel) {
- case 15:
- switch (dst->format->Rmask) {
- case 0x7C00:
- return SDL_BlendPoint_RGB555(dst, x, y, blendMode, r, g, b, a);
- }
- break;
- case 16:
- switch (dst->format->Rmask) {
- case 0xF800:
- return SDL_BlendPoint_RGB565(dst, x, y, blendMode, r, g, b, a);
- }
- break;
- case 32:
- switch (dst->format->Rmask) {
- case 0x00FF0000:
- if (!dst->format->Amask) {
- return SDL_BlendPoint_RGB888(dst, x, y, blendMode, r, g, b,
- a);
- } else {
- return SDL_BlendPoint_ARGB8888(dst, x, y, blendMode, r, g, b,
- a);
- }
- break;
- }
- break;
- default:
- break;
- }
-
- if (!dst->format->Amask) {
- return SDL_BlendPoint_RGB(dst, x, y, blendMode, r, g, b, a);
- } else {
- return SDL_BlendPoint_RGBA(dst, x, y, blendMode, r, g, b, a);
- }
-}
-
-int
-SDL_BlendPoints(SDL_Surface * dst, const SDL_Point * points, int count,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
- int minx, miny;
- int maxx, maxy;
- int i;
- int x, y;
- int (*func)(SDL_Surface * dst, int x, int y,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a) = NULL;
- int status = 0;
-
- if (!dst) {
- SDL_SetError("Passed NULL destination surface");
- return -1;
- }
-
- /* This function doesn't work on surfaces < 8 bpp */
- if (dst->format->BitsPerPixel < 8) {
- SDL_SetError("SDL_BlendPoints(): Unsupported surface format");
- return (-1);
- }
-
- if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
- r = DRAW_MUL(r, a);
- g = DRAW_MUL(g, a);
- b = DRAW_MUL(b, a);
- }
-
- /* FIXME: Does this function pointer slow things down significantly? */
- switch (dst->format->BitsPerPixel) {
- case 15:
- switch (dst->format->Rmask) {
- case 0x7C00:
- func = SDL_BlendPoint_RGB555;
- break;
- }
- break;
- case 16:
- switch (dst->format->Rmask) {
- case 0xF800:
- func = SDL_BlendPoint_RGB565;
- break;
- }
- break;
- case 32:
- switch (dst->format->Rmask) {
- case 0x00FF0000:
- if (!dst->format->Amask) {
- func = SDL_BlendPoint_RGB888;
- } else {
- func = SDL_BlendPoint_ARGB8888;
- }
- break;
- }
- break;
- default:
- break;
- }
-
- if (!func) {
- if (!dst->format->Amask) {
- func = SDL_BlendPoint_RGB;
- } else {
- func = SDL_BlendPoint_RGBA;
- }
- }
-
- minx = dst->clip_rect.x;
- maxx = dst->clip_rect.x + dst->clip_rect.w - 1;
- miny = dst->clip_rect.y;
- maxy = dst->clip_rect.y + dst->clip_rect.h - 1;
-
- for (i = 0; i < count; ++i) {
- x = points[i].x;
- y = points[i].y;
-
- if (x < minx || x > maxx || y < miny || y > maxy) {
- continue;
- }
- status = func(dst, x, y, blendMode, r, g, b, a);
- }
- return status;
-}
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_blendrect.c Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,75 +0,0 @@
-/*
- SDL - Simple DirectMedia Layer
- Copyright (C) 1997-2010 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"
-
-#include "SDL_video.h"
-
-
-int
-SDL_BlendRect(SDL_Surface * dst, const SDL_Rect * rect,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
- SDL_Rect full_rect;
- SDL_Point points[5];
-
- if (!dst) {
- SDL_SetError("Passed NULL destination surface");
- return -1;
- }
-
- /* If 'rect' == NULL, then outline the whole surface */
- if (!rect) {
- full_rect.x = 0;
- full_rect.y = 0;
- full_rect.w = dst->w;
- full_rect.h = dst->h;
- 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_BlendLines(dst, points, 5, blendMode, r, g, b, a);
-}
-
-int
-SDL_BlendRects(SDL_Surface * dst, const SDL_Rect ** rects, int count,
- SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
- int i;
-
- for (i = 0; i < count; ++i) {
- if (SDL_BlendRect(dst, rects[i], blendMode, r, g, b, a) < 0) {
- return -1;
- }
- }
- return 0;
-}
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_blit.h Thu Feb 03 02:42:50 2011 -0800
+++ b/src/video/SDL_blit.h Thu Feb 03 02:45:29 2011 -0800
@@ -47,7 +47,7 @@
#include "SDL_cpuinfo.h"
#include "SDL_endian.h"
-#include "SDL_video.h"
+#include "SDL_surface.h"
/* SDL blit copy flags */
#define SDL_COPY_MODULATE_COLOR 0x00000001
--- a/src/video/SDL_draw.h Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,521 +0,0 @@
-/*
- SDL - Simple DirectMedia Layer
- Copyright (C) 1997-2010 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"
-
-#include "SDL_blit.h"
-
-/* This code assumes that r, g, b, a are the source color,
- * and in the blend and add case, the RGB values are premultiplied by a.
- */
-
-#define DRAW_MUL(_a, _b) (((unsigned)(_a)*(_b))/255)
-
-#define DRAW_FASTSETPIXEL(type) \
- *pixel = (type) color
-
-#define DRAW_FASTSETPIXEL1 DRAW_FASTSETPIXEL(Uint8)
-#define DRAW_FASTSETPIXEL2 DRAW_FASTSETPIXEL(Uint16)
-#define DRAW_FASTSETPIXEL4 DRAW_FASTSETPIXEL(Uint32)
-
-#define DRAW_FASTSETPIXELXY(x, y, type, bpp, color) \
- *(type *)((Uint8 *)dst->pixels + (y) * dst->pitch \
- + (x) * bpp) = (type) color
-
-#define DRAW_FASTSETPIXELXY1(x, y) DRAW_FASTSETPIXELXY(x, y, Uint8, 1, color)
-#define DRAW_FASTSETPIXELXY2(x, y) DRAW_FASTSETPIXELXY(x, y, Uint16, 2, color)
-#define DRAW_FASTSETPIXELXY4(x, y) DRAW_FASTSETPIXELXY(x, y, Uint32, 4, color)
-
-#define DRAW_SETPIXEL(setpixel) \
-do { \
- unsigned sr = r, sg = g, sb = b, sa = a; \
- setpixel; \
-} while (0)
-
-#define DRAW_SETPIXEL_BLEND(getpixel, setpixel) \
-do { \
- unsigned sr, sg, sb, sa; sa; \
- getpixel; \
- sr = DRAW_MUL(inva, sr) + r; \
- sg = DRAW_MUL(inva, sg) + g; \
- sb = DRAW_MUL(inva, sb) + b; \
- setpixel; \
-} while (0)
-
-#define DRAW_SETPIXEL_ADD(getpixel, setpixel) \
-do { \
- unsigned sr, sg, sb, sa; sa; \
- getpixel; \
- sr += r; if (sr > 0xff) sr = 0xff; \
- sg += g; if (sg > 0xff) sg = 0xff; \
- sb += b; if (sb > 0xff) sb = 0xff; \
- setpixel; \
-} while (0)
-
-#define DRAW_SETPIXELXY(x, y, type, bpp, op) \
-do { \
- type *pixel = (type *)((Uint8 *)dst->pixels + (y) * dst->pitch \
- + (x) * bpp); \
- op; \
-} while (0)
-
-/*
- * Define draw operators for RGB555
- */
-
-#define DRAW_SETPIXEL_RGB555 \
- DRAW_SETPIXEL(RGB555_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXEL_BLEND_RGB555 \
- DRAW_SETPIXEL_BLEND(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
- RGB555_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXEL_ADD_RGB555 \
- DRAW_SETPIXEL_ADD(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
- RGB555_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXELXY_RGB555(x, y) \
- DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB555)
-
-#define DRAW_SETPIXELXY_BLEND_RGB555(x, y) \
- DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB555)
-
-#define DRAW_SETPIXELXY_ADD_RGB555(x, y) \
- DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB555)
-
-/*
- * Define draw operators for RGB565
- */
-
-#define DRAW_SETPIXEL_RGB565 \
- DRAW_SETPIXEL(RGB565_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXEL_BLEND_RGB565 \
- DRAW_SETPIXEL_BLEND(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
- RGB565_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXEL_ADD_RGB565 \
- DRAW_SETPIXEL_ADD(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
- RGB565_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXELXY_RGB565(x, y) \
- DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB565)
-
-#define DRAW_SETPIXELXY_BLEND_RGB565(x, y) \
- DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB565)
-
-#define DRAW_SETPIXELXY_ADD_RGB565(x, y) \
- DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB565)
-
-/*
- * Define draw operators for RGB888
- */
-
-#define DRAW_SETPIXEL_RGB888 \
- DRAW_SETPIXEL(RGB888_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXEL_BLEND_RGB888 \
- DRAW_SETPIXEL_BLEND(RGB_FROM_RGB888(*pixel, sr, sg, sb), \
- RGB888_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXEL_ADD_RGB888 \
- DRAW_SETPIXEL_ADD(RGB_FROM_RGB888(*pixel, sr, sg, sb), \
- RGB888_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXELXY_RGB888(x, y) \
- DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGB888)
-
-#define DRAW_SETPIXELXY_BLEND_RGB888(x, y) \
- DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGB888)
-
-#define DRAW_SETPIXELXY_ADD_RGB888(x, y) \
- DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGB888)
-
-/*
- * Define draw operators for ARGB8888
- */
-
-#define DRAW_SETPIXEL_ARGB8888 \
- DRAW_SETPIXEL(ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
-
-#define DRAW_SETPIXEL_BLEND_ARGB8888 \
- DRAW_SETPIXEL_BLEND(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
- ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
-
-#define DRAW_SETPIXEL_ADD_ARGB8888 \
- DRAW_SETPIXEL_ADD(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
- ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
-
-#define DRAW_SETPIXELXY_ARGB8888(x, y) \
- DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ARGB8888)
-
-#define DRAW_SETPIXELXY_BLEND_ARGB8888(x, y) \
- DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_ARGB8888)
-
-#define DRAW_SETPIXELXY_ADD_ARGB8888(x, y) \
- DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_ARGB8888)
-
-/*
- * Define draw operators for general RGB
- */
-
-#define DRAW_SETPIXEL_RGB \
- DRAW_SETPIXEL(PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
-
-#define DRAW_SETPIXEL_BLEND_RGB \
- DRAW_SETPIXEL_BLEND(RGB_FROM_PIXEL(*pixel, fmt, sr, sg, sb), \
- PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
-
-#define DRAW_SETPIXEL_ADD_RGB \
- DRAW_SETPIXEL_ADD(RGB_FROM_PIXEL(*pixel, fmt, sr, sg, sb), \
- PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
-
-#define DRAW_SETPIXELXY2_RGB(x, y) \
- DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB)
-
-#define DRAW_SETPIXELXY4_RGB(x, y) \
- DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGB)
-
-#define DRAW_SETPIXELXY2_BLEND_RGB(x, y) \
- DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB)
-
-#define DRAW_SETPIXELXY4_BLEND_RGB(x, y) \
- DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGB)
-
-#define DRAW_SETPIXELXY2_ADD_RGB(x, y) \
- DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB)
-
-#define DRAW_SETPIXELXY4_ADD_RGB(x, y) \
- DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGB)
-
-
-/*
- * Define draw operators for general RGBA
- */
-
-#define DRAW_SETPIXEL_RGBA \
- DRAW_SETPIXEL(PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
-
-#define DRAW_SETPIXEL_BLEND_RGBA \
- DRAW_SETPIXEL_BLEND(RGBA_FROM_PIXEL(*pixel, fmt, sr, sg, sb, sa), \
- PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
-
-#define DRAW_SETPIXEL_ADD_RGBA \
- DRAW_SETPIXEL_ADD(RGBA_FROM_PIXEL(*pixel, fmt, sr, sg, sb, sa), \
- PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
-
-#define DRAW_SETPIXELXY4_RGBA(x, y) \
- DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGBA)
-
-#define DRAW_SETPIXELXY4_BLEND_RGBA(x, y) \
- DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGBA)
-
-#define DRAW_SETPIXELXY4_ADD_RGBA(x, y) \
- DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGBA)
-
-/*
- * Define line drawing macro
- */
-
-#define ABS(_x) ((_x) < 0 ? -(_x) : (_x))
-
-/* Horizontal line */
-#define HLINE(type, op, draw_end) \
-{ \
- int length; \
- int pitch = (dst->pitch / dst->format->BytesPerPixel); \
- type *pixel; \
- if (x1 <= x2) { \
- pixel = (type *)dst->pixels + y1 * pitch + x1; \
- length = draw_end ? (x2-x1+1) : (x2-x1); \
- } else { \
- pixel = (type *)dst->pixels + y1 * pitch + x2; \
- if (!draw_end) { \
- ++pixel; \
- } \
- length = draw_end ? (x1-x2+1) : (x1-x2); \
- } \
- while (length--) { \
- op; \
- ++pixel; \
- } \
-}
-
-/* Vertical line */
-#define VLINE(type, op, draw_end) \
-{ \
- int length; \
- int pitch = (dst->pitch / dst->format->BytesPerPixel); \
- type *pixel; \
- if (y1 <= y2) { \
- pixel = (type *)dst->pixels + y1 * pitch + x1; \
- length = draw_end ? (y2-y1+1) : (y2-y1); \
- } else { \
- pixel = (type *)dst->pixels + y2 * pitch + x1; \
- if (!draw_end) { \
- pixel += pitch; \
- } \
- length = draw_end ? (y1-y2+1) : (y1-y2); \
- } \
- while (length--) { \
- op; \
- pixel += pitch; \
- } \
-}
-
-/* Diagonal line */
-#define DLINE(type, op, draw_end) \
-{ \
- int length; \
- int pitch = (dst->pitch / dst->format->BytesPerPixel); \
- type *pixel; \
- if (y1 <= y2) { \
- pixel = (type *)dst->pixels + y1 * pitch + x1; \
- if (x1 <= x2) { \
- ++pitch; \
- } else { \
- --pitch; \
- } \
- length = (y2-y1); \
- } else { \
- pixel = (type *)dst->pixels + y2 * pitch + x2; \
- if (x2 <= x1) { \
- ++pitch; \
- } else { \
- --pitch; \
- } \
- if (!draw_end) { \
- pixel += pitch; \
- } \
- length = (y1-y2); \
- } \
- if (draw_end) { \
- ++length; \
- } \
- while (length--) { \
- op; \
- pixel += pitch; \
- } \
-}
-
-/* Bresenham's line algorithm */
-#define BLINE(x1, y1, x2, y2, op, draw_end) \
-{ \
- int i, deltax, deltay, numpixels; \
- int d, dinc1, dinc2; \
- int x, xinc1, xinc2; \
- int y, yinc1, yinc2; \
- \
- deltax = ABS(x2 - x1); \
- deltay = ABS(y2 - y1); \
- \
- if (deltax >= deltay) { \
- numpixels = deltax + 1; \
- d = (2 * deltay) - deltax; \
- dinc1 = deltay * 2; \
- dinc2 = (deltay - deltax) * 2; \
- xinc1 = 1; \
- xinc2 = 1; \
- yinc1 = 0; \
- yinc2 = 1; \
- } else { \
- numpixels = deltay + 1; \
- d = (2 * deltax) - deltay; \
- dinc1 = deltax * 2; \
- dinc2 = (deltax - deltay) * 2; \
- xinc1 = 0; \
- xinc2 = 1; \
- yinc1 = 1; \
- yinc2 = 1; \
- } \
- \
- if (x1 > x2) { \
- xinc1 = -xinc1; \
- xinc2 = -xinc2; \
- } \
- if (y1 > y2) { \
- yinc1 = -yinc1; \
- yinc2 = -yinc2; \
- } \
- \
- x = x1; \
- y = y1; \
- \
- if (!draw_end) { \
- --numpixels; \
- } \
- for (i = 0; i < numpixels; ++i) { \
- op(x, y); \
- if (d < 0) { \
- d += dinc1; \
- x += xinc1; \
- y += yinc1; \
- } else { \
- d += dinc2; \
- x += xinc2; \
- y += yinc2; \
- } \
- } \
-}
-
-/* Xiaolin Wu's line algorithm, based on Michael Abrash's implementation */
-#define WULINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
-{ \
- Uint16 ErrorAdj, ErrorAcc; \
- Uint16 ErrorAccTemp, Weighting; \
- int DeltaX, DeltaY, Temp, XDir; \
- unsigned r, g, b, a, inva; \
- \
- /* Draw the initial pixel, which is always exactly intersected by \
- the line and so needs no weighting */ \
- opaque_op(x1, y1); \
- \
- /* Draw the final pixel, which is always exactly intersected by the line \
- and so needs no weighting */ \
- if (draw_end) { \
- opaque_op(x2, y2); \
- } \
- \
- /* Make sure the line runs top to bottom */ \
- if (y1 > y2) { \
- Temp = y1; y1 = y2; y2 = Temp; \
- Temp = x1; x1 = x2; x2 = Temp; \
- } \
- DeltaY = y2 - y1; \
- \
- if ((DeltaX = x2 - x1) >= 0) { \
- XDir = 1; \
- } else { \
- XDir = -1; \
- DeltaX = -DeltaX; /* make DeltaX positive */ \
- } \
- \
- /* line is not horizontal, diagonal, or vertical */ \
- ErrorAcc = 0; /* initialize the line error accumulator to 0 */ \
- \
- /* Is this an X-major or Y-major line? */ \
- if (DeltaY > DeltaX) { \
- /* Y-major line; calculate 16-bit fixed-point fractional part of a \
- pixel that X advances each time Y advances 1 pixel, truncating the \
- result so that we won't overrun the endpoint along the X axis */ \
- ErrorAdj = ((unsigned long) DeltaX << 16) / (unsigned long) DeltaY; \
- /* Draw all pixels other than the first and last */ \
- while (--DeltaY) { \
- ErrorAccTemp = ErrorAcc; /* remember currrent accumulated error */ \
- ErrorAcc += ErrorAdj; /* calculate error for next pixel */ \
- if (ErrorAcc <= ErrorAccTemp) { \
- /* The error accumulator turned over, so advance the X coord */ \
- x1 += XDir; \
- } \
- y1++; /* Y-major, so always advance Y */ \
- /* The IntensityBits most significant bits of ErrorAcc give us the \
- intensity weighting for this pixel, and the complement of the \
- weighting for the paired pixel */ \
- Weighting = ErrorAcc >> 8; \
- { \
- a = DRAW_MUL(_a, (Weighting ^ 255)); \
- r = DRAW_MUL(_r, a); \
- g = DRAW_MUL(_g, a); \
- b = DRAW_MUL(_b, a); \
- inva = (a ^ 0xFF); \
- blend_op(x1, y1); \
- } \
- { \
- a = DRAW_MUL(_a, Weighting); \
- r = DRAW_MUL(_r, a); \
- g = DRAW_MUL(_g, a); \
- b = DRAW_MUL(_b, a); \
- inva = (a ^ 0xFF); \
- blend_op(x1 + XDir, y1); \
- } \
- } \
- } else { \
- /* X-major line; calculate 16-bit fixed-point fractional part of a \
- pixel that Y advances each time X advances 1 pixel, truncating the \
- result to avoid overrunning the endpoint along the X axis */ \
- ErrorAdj = ((unsigned long) DeltaY << 16) / (unsigned long) DeltaX; \
- /* Draw all pixels other than the first and last */ \
- while (--DeltaX) { \
- ErrorAccTemp = ErrorAcc; /* remember currrent accumulated error */ \
- ErrorAcc += ErrorAdj; /* calculate error for next pixel */ \
- if (ErrorAcc <= ErrorAccTemp) { \
- /* The error accumulator turned over, so advance the Y coord */ \
- y1++; \
- } \
- x1 += XDir; /* X-major, so always advance X */ \
- /* The IntensityBits most significant bits of ErrorAcc give us the \
- intensity weighting for this pixel, and the complement of the \
- weighting for the paired pixel */ \
- Weighting = ErrorAcc >> 8; \
- { \
- a = DRAW_MUL(_a, (Weighting ^ 255)); \
- r = DRAW_MUL(_r, a); \
- g = DRAW_MUL(_g, a); \
- b = DRAW_MUL(_b, a); \
- inva = (a ^ 0xFF); \
- blend_op(x1, y1); \
- } \
- { \
- a = DRAW_MUL(_a, Weighting); \
- r = DRAW_MUL(_r, a); \
- g = DRAW_MUL(_g, a); \
- b = DRAW_MUL(_b, a); \
- inva = (a ^ 0xFF); \
- blend_op(x1, y1 + 1); \
- } \
- } \
- } \
-}
-
-#ifdef AA_LINES
-#define AALINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
- WULINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end)
-#else
-#define AALINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
- BLINE(x1, y1, x2, y2, opaque_op, draw_end)
-#endif
-
-/*
- * Define fill rect macro
- */
-
-#define FILLRECT(type, op) \
-do { \
- int width = rect->w; \
- int height = rect->h; \
- int pitch = (dst->pitch / dst->format->BytesPerPixel); \
- int skip = pitch - width; \
- type *pixel = (type *)dst->pixels + rect->y * pitch + rect->x; \
- while (height--) { \
- { int n = (width+3)/4; \
- switch (width & 3) { \
- case 0: do { op; pixel++; \
- case 3: op; pixel++; \
- case 2: op; pixel++; \
- case 1: op; pixel++; \
- } while ( --n > 0 ); \
- } \
- } \
- pixel += skip; \
- } \
-} while (0)
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_drawline.c Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,208 +0,0 @@
-/*
- SDL - Simple DirectMedia Layer
- Copyright (C) 1997-2010 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"
-
-#include "SDL_draw.h"
-
-static void
-SDL_DrawLine1(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color,
- SDL_bool draw_end)
-{
- if (y1 == y2) {
- //HLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
- int length;
- int pitch = (dst->pitch / dst->format->BytesPerPixel);
- Uint8 *pixel;
- if (x1 <= x2) {
- pixel = (Uint8 *)dst->pixels + y1 * pitch + x1;
- length = draw_end ? (x2-x1+1) : (x2-x1);
- } else {
- pixel = (Uint8 *)dst->pixels + y1 * pitch + x2;
- if (!draw_end) {
- ++pixel;
- }
- length = draw_end ? (x1-x2+1) : (x1-x2);
- }
- SDL_memset(pixel, color, length);
- } else if (x1 == x2) {
- VLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
- } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
- DLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
- } else {
- BLINE(x1, y1, x2, y2, DRAW_FASTSETPIXELXY1, draw_end);
- }
-}
-
-static void
-SDL_DrawLine2(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color,
- SDL_bool draw_end)
-{
- if (y1 == y2) {
- HLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
- } else if (x1 == x2) {
- VLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
- } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
- DLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
- } else {
- Uint8 _r, _g, _b, _a;
- const SDL_PixelFormat * fmt = dst->format;
- SDL_GetRGBA(color, fmt, &_r, &_g, &_b, &_a);
- if (fmt->Rmask == 0x7C00) {
- AALINE(x1, y1, x2, y2,
- DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY_BLEND_RGB555,
- draw_end);
- } else if (fmt->Rmask == 0xF800) {
- AALINE(x1, y1, x2, y2,
- DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY_BLEND_RGB565,
- draw_end);
- } else {
- AALINE(x1, y1, x2, y2,
- DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY2_BLEND_RGB,
- draw_end);
- }
- }
-}
-
-static void
-SDL_DrawLine4(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color,
- SDL_bool draw_end)
-{
- if (y1 == y2) {
- HLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
- } else if (x1 == x2) {
- VLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
- } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
- DLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
- } else {
- Uint8 _r, _g, _b, _a;
- const SDL_PixelFormat * fmt = dst->format;
- SDL_GetRGBA(color, fmt, &_r, &_g, &_b, &_a);
- if (fmt->Rmask == 0x00FF0000) {
- if (!fmt->Amask) {
- AALINE(x1, y1, x2, y2,
- DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY_BLEND_RGB888,
- draw_end);
- } else {
- AALINE(x1, y1, x2, y2,
- DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY_BLEND_ARGB8888,
- draw_end);
- }
- } else {
- AALINE(x1, y1, x2, y2,
- DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY4_BLEND_RGB,
- draw_end);
- }
- }
-}
-
-typedef void (*DrawLineFunc) (SDL_Surface * dst,
- int x1, int y1, int x2, int y2,
- Uint32 color, SDL_bool draw_end);
-
-static DrawLineFunc
-SDL_CalculateDrawLineFunc(const SDL_PixelFormat * fmt)
-{
- switch (fmt->BytesPerPixel) {
- case 1:
- if (fmt->BitsPerPixel < 8) {
- break;
- }
- return SDL_DrawLine1;
- case 2:
- return SDL_DrawLine2;
- case 4:
- return SDL_DrawLine4;
- }
- return NULL;
-}
-
-int
-SDL_DrawLine(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color)
-{
- DrawLineFunc func;
-
- if (!dst) {
- SDL_SetError("SDL_DrawLine(): Passed NULL destination surface");
- return -1;
- }
-
- func = SDL_CalculateDrawLineFunc(dst->format);
- if (!func) {
- SDL_SetError("SDL_DrawLine(): Unsupported surface format");
- return -1;
- }
-
- /* Perform clipping */
- /* FIXME: We don't actually want to clip, as it may change line slope */
- if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
- return 0;
- }
-
- func(dst, x1, y1, x2, y2, color, SDL_TRUE);
- return 0;
-}
-
-int
-SDL_DrawLines(SDL_Surface * dst, const SDL_Point * points, int count,
- Uint32 color)
-{
- int i;
- int x1, y1;
- int x2, y2;
- SDL_bool draw_end;
- DrawLineFunc func;
-
- if (!dst) {
- SDL_SetError("SDL_DrawLines(): Passed NULL destination surface");
- return -1;
- }
-
- func = SDL_CalculateDrawLineFunc(dst->format);
- if (!func) {
- SDL_SetError("SDL_DrawLines(): Unsupported surface format");
- return -1;
- }
-
- for (i = 1; i < count; ++i) {
- x1 = points[i-1].x;
- y1 = points[i-1].y;
- x2 = points[i].x;
- y2 = points[i].y;
-
- /* Perform clipping */
- /* FIXME: We don't actually want to clip, as it may change line slope */
- if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
- continue;
- }
-
- /* Draw the end if it was clipped */
- draw_end = (x2 != points[i].x || y2 != points[i].y);
-
- func(dst, x1, y1, x2, y2, color, draw_end);
- }
- if (points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
- SDL_DrawPoint(dst, points[count-1].x, points[count-1].y, color);
- }
- return 0;
-}
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_drawpoint.c Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,116 +0,0 @@
-/*
- SDL - Simple DirectMedia Layer
- Copyright (C) 1997-2010 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"
-
-#include "SDL_draw.h"
-
-
-int
-SDL_DrawPoint(SDL_Surface * dst, int x, int y, Uint32 color)
-{
- if (!dst) {
- SDL_SetError("Passed NULL destination surface");
- return -1;
- }
-
- /* This function doesn't work on surfaces < 8 bpp */
- if (dst->format->BitsPerPixel < 8) {
- SDL_SetError("SDL_DrawPoint(): Unsupported surface format");
- return -1;
- }
-
- /* Perform clipping */
- if (x < dst->clip_rect.x || y < dst->clip_rect.y ||
- x >= (dst->clip_rect.x + dst->clip_rect.w) ||
- y >= (dst->clip_rect.y + dst->clip_rect.h)) {
- return 0;
- }
-
- switch (dst->format->BytesPerPixel) {
- case 1:
- DRAW_FASTSETPIXELXY1(x, y);
- break;
- case 2:
- DRAW_FASTSETPIXELXY2(x, y);
- break;
- case 3:
- SDL_Unsupported();
- return -1;
- case 4:
- DRAW_FASTSETPIXELXY4(x, y);
- break;
- }
- return 0;
-}
-
-int
-SDL_DrawPoints(SDL_Surface * dst, const SDL_Point * points, int count,
- Uint32 color)
-{
- int minx, miny;
- int maxx, maxy;
- int i;
- int x, y;
-
- if (!dst) {
- SDL_SetError("Passed NULL destination surface");
- return -1;
- }
-
- /* This function doesn't work on surfaces < 8 bpp */
- if (dst->format->BitsPerPixel < 8) {
- SDL_SetError("SDL_DrawPoints(): Unsupported surface format");
- return -1;
- }
-
- minx = dst->clip_rect.x;
- maxx = dst->clip_rect.x + dst->clip_rect.w - 1;
- miny = dst->clip_rect.y;
- maxy = dst->clip_rect.y + dst->clip_rect.h - 1;
-
- for (i = 0; i < count; ++i) {
- x = points[i].x;
- y = points[i].y;
-
- if (x < minx || x > maxx || y < miny || y > maxy) {
- continue;
- }
-
- switch (dst->format->BytesPerPixel) {
- case 1:
- DRAW_FASTSETPIXELXY1(x, y);
- break;
- case 2:
- DRAW_FASTSETPIXELXY2(x, y);
- break;
- case 3:
- SDL_Unsupported();
- return -1;
- case 4:
- DRAW_FASTSETPIXELXY4(x, y);
- break;
- }
- }
- return 0;
-}
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_drawrect.c Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,74 +0,0 @@
-/*
- SDL - Simple DirectMedia Layer
- Copyright (C) 1997-2010 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"
-
-#include "SDL_video.h"
-
-
-int
-SDL_DrawRect(SDL_Surface * dst, const SDL_Rect * rect, Uint32 color)
-{
- SDL_Rect full_rect;
- SDL_Point points[5];
-
- if (!dst) {
- SDL_SetError("Passed NULL destination surface");
- return -1;
- }
-
- /* If 'rect' == NULL, then outline the whole surface */
- if (!rect) {
- full_rect.x = 0;
- full_rect.y = 0;
- full_rect.w = dst->w;
- full_rect.h = dst->h;
- 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_DrawLines(dst, points, 5, color);
-}
-
-int
-SDL_DrawRects(SDL_Surface * dst, const SDL_Rect ** rects, int count,
- Uint32 color)
-{
- int i;
-
- for (i = 0; i < count; ++i) {
- if (SDL_DrawRect(dst, rects[i], color) < 0) {
- return -1;
- }
- }
- return 0;
-}
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/test/automated/surface/surface.c Thu Feb 03 02:42:50 2011 -0800
+++ b/test/automated/surface/surface.c Thu Feb 03 02:45:29 2011 -0800
@@ -26,8 +26,6 @@
*/
/* Testcases. */
static void surface_testLoad( SDL_Surface *testsur );
-static void surface_testPrimitives( SDL_Surface *testsur );
-static void surface_testPrimitivesBlend( SDL_Surface *testsur );
static void surface_testBlit( SDL_Surface *testsur );
static int surface_testBlitBlendMode( SDL_Surface *testsur, SDL_Surface *face, int mode );
static void surface_testBlitBlend( SDL_Surface *testsur );
@@ -85,167 +83,6 @@
/**
- * @brief Tests the SDL primitives for rendering.
- */
-static void surface_testPrimitives( SDL_Surface *testsur )
-{
- int ret;
- int x, y;
- SDL_Rect rect;
-
- SDL_ATbegin( "Primitives Test" );
-
- /* Clear surface. */
- ret = SDL_FillRect( testsur, NULL,
- SDL_MapRGB( testsur->format, 0, 0, 0 ) );
- if (SDL_ATassert( "SDL_FillRect", ret == 0))
- return;
-
- /* Draw a rectangle. */
- rect.x = 40;
- rect.y = 0;
- rect.w = 40;
- rect.h = 80;
- ret = SDL_FillRect( testsur, &rect,
- SDL_MapRGB( testsur->format, 13, 73, 200 ) );
- if (SDL_ATassert( "SDL_FillRect", ret == 0))
- return;
-
- /* Draw a rectangle. */
- rect.x = 10;
- rect.y = 10;
- rect.w = 60;
- rect.h = 40;
- ret = SDL_FillRect( testsur, &rect,
- SDL_MapRGB( testsur->format, 200, 0, 100 ) );
- if (SDL_ATassert( "SDL_FillRect", ret == 0))
- return;
-
- /* Draw some points like so:
- * X.X.X.X..
- * .X.X.X.X.
- * X.X.X.X.. */
- for (y=0; y<3; y++) {
- x = y % 2;
- for (; x<80; x+=2) {
- ret = SDL_DrawPoint( testsur, x, y,
- SDL_MapRGB( testsur->format, x*y, x*y/2, x*y/3 ) );
- if (SDL_ATassert( "SDL_DrawPoint", ret == 0))
- return;
- }
- }
-
- /* Draw some lines. */
- ret = SDL_DrawLine( testsur, 0, 30, 80, 30,
- SDL_MapRGB( testsur->format, 0, 255, 0 ) );
- if (SDL_ATassert( "SDL_DrawLine", ret == 0))
- return;
- ret = SDL_DrawLine( testsur, 40, 30, 40, 60,
- SDL_MapRGB( testsur->format, 55, 55, 5 ) );
- if (SDL_ATassert( "SDL_DrawLine", ret == 0))
- return;
- ret = SDL_DrawLine( testsur, 0, 0, 29, 29,
- SDL_MapRGB( testsur->format, 5, 105, 105 ) );
- if (SDL_ATassert( "SDL_DrawLine", ret == 0))
- return;
- ret = SDL_DrawLine( testsur, 29, 30, 0, 59,
- SDL_MapRGB( testsur->format, 5, 105, 105 ) );
- if (SDL_ATassert( "SDL_DrawLine", ret == 0))
- return;
- ret = SDL_DrawLine( testsur, 79, 0, 50, 29,
- SDL_MapRGB( testsur->format, 5, 105, 105 ) );
- if (SDL_ATassert( "SDL_DrawLine", ret == 0))
- return;
- ret = SDL_DrawLine( testsur, 79, 59, 50, 30,
- SDL_MapRGB( testsur->format, 5, 105, 105 ) );
- if (SDL_ATassert( "SDL_DrawLine", ret == 0))
- return;
-
- /* See if it's the same. */
- if (SDL_ATassert( "Primitives output not the same.",
- surface_compare( testsur, &img_primitives, 0 )==0 ))
- return;
-
- SDL_ATend();
-}
-
-
-/**
- * @brief Tests the SDL primitives with alpha for rendering.
- */
-static void surface_testPrimitivesBlend( SDL_Surface *testsur )
-{
- int ret;
- int i, j;
- SDL_Rect rect;
-
- SDL_ATbegin( "Primitives Blend Test" );
-
- /* Clear surface. */
- ret = SDL_FillRect( testsur, NULL,
- SDL_MapRGB( testsur->format, 0, 0, 0 ) );
- if (SDL_ATassert( "SDL_FillRect", ret == 0))
- return;
-
- /* Create some rectangles for each blend mode. */
- ret = SDL_BlendFillRect( testsur, NULL, SDL_BLENDMODE_NONE, 255, 255, 255, 0 );
- if (SDL_ATassert( "SDL_BlendFillRect", ret == 0))
- return;
- rect.x = 10;
- rect.y = 25;
- rect.w = 40;
- rect.h = 25;
- ret = SDL_BlendFillRect( testsur, &rect, SDL_BLENDMODE_ADD, 240, 10, 10, 75 );
- if (SDL_ATassert( "SDL_BlendFillRect", ret == 0))
- return;
- rect.x = 30;
- rect.y = 40;
- rect.w = 45;
- rect.h = 15;
- ret = SDL_BlendFillRect( testsur, &rect, SDL_BLENDMODE_BLEND, 10, 240, 10, 100 );
- if (SDL_ATassert( "SDL_BlendFillRect", ret == 0))
- return;
-
- /* Draw blended lines, lines for everyone. */
- for (i=0; i<testsur->w; i+=2) {
- ret = SDL_BlendLine( testsur, 0, 0, i, 59,
- (((i/2)%3)==0) ? SDL_BLENDMODE_BLEND :
- (((i/2)%3)==1) ? SDL_BLENDMODE_ADD : SDL_BLENDMODE_NONE,
- 60+2*i, 240-2*i, 50, 3*i );
- if (SDL_ATassert( "SDL_BlendLine", ret == 0))
- return;
- }
- for (i=0; i<testsur->h; i+=2) {
- ret = SDL_BlendLine( testsur, 0, 0, 79, i,
- (((i/2)%3)==0) ? SDL_BLENDMODE_BLEND :
- (((i/2)%3)==1) ? SDL_BLENDMODE_ADD : SDL_BLENDMODE_NONE,
- 60+2*i, 240-2*i, 50, 3*i );
- if (SDL_ATassert( "SDL_BlendLine", ret == 0))
- return;
- }
-
- /* Draw points. */
- for (j=0; j<testsur->h; j+=3) {
- for (i=0; i<testsur->w; i+=3) {
- ret = SDL_BlendPoint( testsur, i, j,
- ((((i+j)/3)%3)==0) ? SDL_BLENDMODE_BLEND :
- ((((i+j)/3)%3)==1) ? SDL_BLENDMODE_ADD : SDL_BLENDMODE_NONE,
- j*4, i*3, j*4, i*3 );
- if (SDL_ATassert( "SDL_BlendPoint", ret == 0))
- return;
- }
- }
-
- /* See if it's the same. */
- if (SDL_ATassert( "Primitives output not the same.",
- surface_compare( testsur, &img_blend, 0 )==0 ))
- return;
-
- SDL_ATend();
-}
-
-
-/**
* @brief Tests some blitting routines.
*/
static void surface_testBlit( SDL_Surface *testsur )
@@ -546,8 +383,6 @@
void surface_runTests( SDL_Surface *testsur )
{
/* Software surface blitting. */
- surface_testPrimitives( testsur );
- surface_testPrimitivesBlend( testsur );
surface_testBlit( testsur );
surface_testBlitBlend( testsur );
}