# HG changeset patch # User Sam Lantinga # Date 1296729929 28800 # Node ID d72793305335efefe8e4a536181bb881ae9cc2d8 # Parent e2b3f003e08526d23209638e43f398aa7212a8c5 Making the API simpler, moved the surface drawing functions to the software renderer. diff -r e2b3f003e085 -r d72793305335 include/SDL_surface.h --- 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 diff -r e2b3f003e085 -r d72793305335 src/render/software/SDL_blendfillrect.c --- /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: */ diff -r e2b3f003e085 -r d72793305335 src/render/software/SDL_blendfillrect.h --- /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: */ diff -r e2b3f003e085 -r d72793305335 src/render/software/SDL_blendline.c --- /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: */ diff -r e2b3f003e085 -r d72793305335 src/render/software/SDL_blendline.h --- /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: */ diff -r e2b3f003e085 -r d72793305335 src/render/software/SDL_blendpoint.c --- /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: */ diff -r e2b3f003e085 -r d72793305335 src/render/software/SDL_blendpoint.h --- /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: */ diff -r e2b3f003e085 -r d72793305335 src/render/software/SDL_draw.h --- /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: */ diff -r e2b3f003e085 -r d72793305335 src/render/software/SDL_drawline.c --- /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: */ diff -r e2b3f003e085 -r d72793305335 src/render/software/SDL_drawline.h --- /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: */ diff -r e2b3f003e085 -r d72793305335 src/render/software/SDL_drawpoint.c --- /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: */ diff -r e2b3f003e085 -r d72793305335 src/render/software/SDL_drawpoint.h --- /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: */ diff -r e2b3f003e085 -r d72793305335 src/render/software/SDL_renderer_sw.c --- 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 */ diff -r e2b3f003e085 -r d72793305335 src/video/SDL_alphamult.c --- 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: */ diff -r e2b3f003e085 -r d72793305335 src/video/SDL_alphamult.h --- 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: */ diff -r e2b3f003e085 -r d72793305335 src/video/SDL_blendfillrect.c --- 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: */ diff -r e2b3f003e085 -r d72793305335 src/video/SDL_blendline.c --- 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: */ diff -r e2b3f003e085 -r d72793305335 src/video/SDL_blendpoint.c --- 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: */ diff -r e2b3f003e085 -r d72793305335 src/video/SDL_blendrect.c --- 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: */ diff -r e2b3f003e085 -r d72793305335 src/video/SDL_blit.h --- 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 diff -r e2b3f003e085 -r d72793305335 src/video/SDL_draw.h --- 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: */ diff -r e2b3f003e085 -r d72793305335 src/video/SDL_drawline.c --- 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: */ diff -r e2b3f003e085 -r d72793305335 src/video/SDL_drawpoint.c --- 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: */ diff -r e2b3f003e085 -r d72793305335 src/video/SDL_drawrect.c --- 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: */ diff -r e2b3f003e085 -r d72793305335 test/automated/surface/surface.c --- 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; iw; 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; ih; 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; jh; j+=3) { - for (i=0; iw; 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 ); }