Skip to content

L
libSDL
Commit d95e51d2 authored by Sam Lantinga's avatar Sam Lantinga
Browse files
Options

Share code between fill and line drawing 

Added general RGB surface format fallbacks to drawing code
Fixed issues with destination surface alpha channel

--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%403360
parent 7b2e58c8
Show whitespace changes
Inline Side-by-side
Showing with 677 additions and 336 deletions
src/video/SDL_blendline.c
View file @ d95e51d2
......@@ -21,198 +21,212 @@
*/
#include "SDL_config.h"
#include "SDL_video.h"
#include "SDL_blit.h"
#define ABS(_x) ((_x) < 0 ? -(_x) : (_x))
#define SWAP(_x, _y) do { int tmp; tmp = _x; _x = _y; _y = tmp; } while (0)
#define BRESENHAM(x0, y0, x1, y1, op) \
{ \
int deltax, deltay, steep, error, xstep, ystep, x, y; \
\
deltax = ABS(x1 - x0); \
deltay = ABS(y1 - y0); \
steep = (deltay > deltax); \
if (steep) { \
SWAP(x0, y0); \
SWAP(x1, y1); \
SWAP(deltax, deltay); \
} \
error = (x1 - x0) / 2; \
y = y0; \
if (x0 > x1) { \
xstep = -1; \
} else { \
xstep = 1; \
} \
if (y0 < y1) { \
ystep = 1; \
} else { \
ystep = -1; \
} \
if (!steep) { \
for (x = x0; x != x1; x += xstep) { \
op(x, y); \
error -= deltay; \
if (error < 0) { \
y += ystep; \
error += deltax; \
} \
} \
} else { \
for (x = x0; x != x1; x += xstep) { \
op(y, x); \
error -= deltay; \
if (error < 0) { \
y += ystep; \
error += deltax; \
} \
} \
} \
}
#define MUL(_a, _b) (((Uint16)(_a)*(Uint16)(_b))/255)
#define SHIFTAND(_v, _s, _a) (((_v)>>(_s)) & _a)
#define SETPIXEL_MASK(x, y, type, bpp, rshift, gshift, bshift, rmask, gmask, bmask) \
do { \
type *pixel = (type *)(dst->pixels + y * dst->pitch + x * bpp); \
if (a) { \
*pixel = (r<<rshift) | (g<<gshift) | (b<<bshift); \
} \
} while (0)
#define SETPIXEL_BLEND(x, y, type, bpp, rshift, gshift, bshift, rmask, gmask, bmask) \
do { \
type *pixel = (type *)(dst->pixels + y * dst->pitch + x * bpp); \
Uint8 sr = MUL(inva, SHIFTAND(*pixel, rshift, rmask)) + (Uint16) r; \
Uint8 sg = MUL(inva, SHIFTAND(*pixel, gshift, gmask)) + (Uint16) g; \
Uint8 sb = MUL(inva, SHIFTAND(*pixel, bshift, bmask)) + (Uint16) b; \
*pixel = (sr<<rshift) | (sg<<gshift) | (sb<<bshift); \
} while (0)
#define SETPIXEL_ADD(x, y, type, bpp, rshift, gshift, bshift, rmask, gmask, bmask) \
do { \
type *pixel = (type *)(dst->pixels + y * dst->pitch + x * bpp); \
Uint16 sr = SHIFTAND(*pixel, rshift, rmask) + (Uint16) r; \
Uint16 sg = SHIFTAND(*pixel, gshift, gmask) + (Uint16) g; \
Uint16 sb = SHIFTAND(*pixel, bshift, bmask) + (Uint16) b; \
if (sr>rmask) sr = rmask; \
if (sg>gmask) sg = gmask; \
if (sb>bmask) sb = bmask; \
*pixel = (sr<<rshift) | (sg<<gshift) | (sb<<bshift); \
} while (0)
#define SETPIXEL_MOD(x, y, type, bpp, rshift, gshift, bshift, rmask, gmask, bmask) \
do { \
type *pixel = (type *)(dst->pixels + y * dst->pitch + x * bpp); \
Uint8 sr = MUL(SHIFTAND(*pixel, rshift, rmask), r); \
Uint8 sg = MUL(SHIFTAND(*pixel, gshift, gmask), g); \
Uint8 sb = MUL(SHIFTAND(*pixel, bshift, bmask), b); \
*pixel = (sr<<rshift) | (sg<<gshift) | (sb<<bshift); \
} while (0)
#define SETPIXEL15_MASK(x, y) SETPIXEL_MASK(x, y, Uint16, 2, 10, 5, 0, 0x1f, 0x1f, 0x1f);
#define SETPIXEL15_BLEND(x, y) SETPIXEL_BLEND(x, y, Uint16, 2, 10, 5, 0, 0x1f, 0x1f, 0x1f);
#define SETPIXEL15_ADD(x, y) SETPIXEL_ADD(x, y, Uint16, 2, 10, 5, 0, 0x1f, 0x1f, 0x1f);
#define SETPIXEL15_MOD(x, y) SETPIXEL_MOD(x, y, Uint16, 2, 10, 5, 0, 0x1f, 0x1f, 0x1f);
#define SETPIXEL16_MASK(x, y) SETPIXEL_MASK(x, y, Uint16, 2, 11, 5, 0, 0x1f, 0x3f, 0x1f);
#define SETPIXEL16_BLEND(x, y) SETPIXEL_BLEND(x, y, Uint16, 2, 11, 5, 0, 0x1f, 0x3f, 0x1f);
#define SETPIXEL16_ADD(x, y) SETPIXEL_ADD(x, y, Uint16, 2, 11, 5, 0, 0x1f, 0x3f, 0x1f);
#define SETPIXEL16_MOD(x, y) SETPIXEL_MOD(x, y, Uint16, 2, 11, 5, 0, 0x1f, 0x3f, 0x1f);
#define SETPIXEL32_MASK(x, y) SETPIXEL_MASK(x, y, Uint32, 4, 16, 8, 0, 0xff, 0xff, 0xff);
#define SETPIXEL32_BLEND(x, y) SETPIXEL_BLEND(x, y, Uint32, 4, 16, 8, 0, 0xff, 0xff, 0xff);
#define SETPIXEL32_ADD(x, y) SETPIXEL_ADD(x, y, Uint32, 4, 16, 8, 0, 0xff, 0xff, 0xff);
#define SETPIXEL32_MOD(x, y) SETPIXEL_MOD(x, y, Uint32, 4, 16, 8, 0, 0xff, 0xff, 0xff);
#include "SDL_draw.h"
int
SDL_BlendLine(SDL_Surface * dst, int x1, int y1, int x2, int y2,
static int
SDL_BlendLine_RGB555(SDL_Surface * dst, int x1, int y1, int x2, int y2,
int blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
{
Uint8 inva = 0xff - a;
/* This function doesn't work on surfaces < 8 bpp */
if (dst->format->BitsPerPixel < 8) {
SDL_SetError("SDL_BlendLine(): Unsupported surface format");
return (-1);
}
unsigned inva = 0xff - a;
/* Perform clipping */
/* FIXME
if (!SDL_IntersectRect(dstrect, &dst->clip_rect, dstrect)) {
return (0);
switch (blendMode) {
case SDL_BLENDMODE_BLEND:
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY_BLEND_RGB555);
break;
case SDL_BLENDMODE_ADD:
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY_ADD_RGB555);
break;
case SDL_BLENDMODE_MOD:
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY_MOD_RGB555);
break;
default:
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY_RGB555);
break;
}
*/
return 0;
}
static int
SDL_BlendLine_RGB565(SDL_Surface * dst, int x1, int y1, int x2, int y2,
int blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
{
unsigned inva = 0xff - a;
if ((blendMode == SDL_BLENDMODE_BLEND)
|| (blendMode == SDL_BLENDMODE_ADD)) {
r = MUL(r, a);
g = MUL(g, a);
b = MUL(b, a);
}
switch (dst->format->BitsPerPixel) {
case 15:
switch (blendMode) {
case SDL_BLENDMODE_MASK:
BRESENHAM(x1, y1, x2, y2, SETPIXEL15_MASK);
break;
case SDL_BLENDMODE_BLEND:
BRESENHAM(x1, y1, x2, y2, SETPIXEL15_BLEND);
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY_BLEND_RGB565);
break;
case SDL_BLENDMODE_ADD:
BRESENHAM(x1, y1, x2, y2, SETPIXEL15_ADD);
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY_ADD_RGB565);
break;
case SDL_BLENDMODE_MOD:
BRESENHAM(x1, y1, x2, y2, SETPIXEL15_MOD);
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY_MOD_RGB565);
break;
}
default:
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY_RGB565);
break;
case 16:
}
return 0;
}
static int
SDL_BlendLine_RGB888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
int blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
{
unsigned inva = 0xff - a;
switch (blendMode) {
case SDL_BLENDMODE_MASK:
BRESENHAM(x1, y1, x2, y2, SETPIXEL16_MASK);
case SDL_BLENDMODE_BLEND:
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY_BLEND_RGB888);
break;
case SDL_BLENDMODE_ADD:
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY_ADD_RGB888);
break;
case SDL_BLENDMODE_MOD:
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY_MOD_RGB888);
break;
default:
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY_RGB888);
break;
}
return 0;
}
static int
SDL_BlendLine_RGB(SDL_Surface * dst, int x1, int y1, int x2, int y2,
int 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:
BRESENHAM(x1, y1, x2, y2, SETPIXEL16_BLEND);
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY2_BLEND_RGB);
break;
case SDL_BLENDMODE_ADD:
BRESENHAM(x1, y1, x2, y2, SETPIXEL16_ADD);
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY2_ADD_RGB);
break;
case SDL_BLENDMODE_MOD:
BRESENHAM(x1, y1, x2, y2, SETPIXEL16_MOD);
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY2_MOD_RGB);
break;
default:
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY2_RGB);
break;
}
return 0;
case 4:
switch (blendMode) {
case SDL_BLENDMODE_BLEND:
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY4_BLEND_RGB);
break;
case 24:
case 32:
if (dst->format->BytesPerPixel != 4) {
case SDL_BLENDMODE_ADD:
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY4_ADD_RGB);
break;
case SDL_BLENDMODE_MOD:
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY4_MOD_RGB);
break;
default:
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY4_RGB);
break;
}
return 0;
default:
SDL_Unsupported();
return -1;
}
}
static int
SDL_BlendLine_RGBA(SDL_Surface * dst, int x1, int y1, int x2, int y2,
int 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_MASK:
BRESENHAM(x1, y1, x2, y2, SETPIXEL32_MASK);
break;
case SDL_BLENDMODE_BLEND:
BRESENHAM(x1, y1, x2, y2, SETPIXEL32_BLEND);
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY4_BLEND_RGBA);
break;
case SDL_BLENDMODE_ADD:
BRESENHAM(x1, y1, x2, y2, SETPIXEL32_ADD);
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY4_ADD_RGBA);
break;
case SDL_BLENDMODE_MOD:
BRESENHAM(x1, y1, x2, y2, SETPIXEL32_MOD);
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY4_MOD_RGBA);
break;
}
default:
BRESENHAM(x1, y1, x2, y2, DRAW_SETPIXELXY4_RGBA);
break;
}
return 0;
default:
SDL_Unsupported();
return -1;
}
return 0;
}
int
SDL_BlendLine(SDL_Surface * dst, int x1, int y1, int x2, int y2,
int blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
{
SDL_PixelFormat *fmt = dst->format;
/* This function doesn't work on surfaces < 8 bpp */
if (dst->format->BitsPerPixel < 8) {
SDL_SetError("SDL_BlendLine(): Unsupported surface format");
return (-1);
}
/* Perform clipping */
/* FIXME
if (!SDL_IntersectRect(dstrect, &dst->clip_rect, dstrect)) {
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 (fmt->BitsPerPixel) {
case 15:
switch (fmt->Rmask) {
case 0x7C00:
return SDL_BlendLine_RGB555(dst, x1, y1, x2, y2, blendMode, r, g,
b, a);
}
break;
case 16:
switch (fmt->Rmask) {
case 0xF800:
return SDL_BlendLine_RGB565(dst, x1, y1, x2, y2, blendMode, r, g,
b, a);
}
break;
case 32:
switch (fmt->Rmask) {
case 0x00FF0000:
if (!fmt->Amask) {
return SDL_BlendLine_RGB888(dst, x1, y1, x2, y2, blendMode, r,
g, b, a);
}
break;
}
default:
break;
}
if (!fmt->Amask) {
return SDL_BlendLine_RGB(dst, x1, y1, x2, y2, blendMode, r, g, b, a);
} else {
return SDL_BlendLine_RGBA(dst, x1, y1, x2, y2, blendMode, r, g, b, a);
}
}
/* vi: set ts=4 sw=4 expandtab: */
src/video/SDL_blendrect.c
View file @ d95e51d2
......@@ -22,163 +22,213 @@
#include "SDL_config.h"
#include "SDL_video.h"
#include "SDL_blit.h"
#define MUL(_a, _b) (((Uint16)(_a)*(Uint16)(_b))/255)
#define SHIFTAND(_v, _s, _a) (((_v)>>(_s)) & (_a))
#define SETPIXEL_MASK(p, type, bpp, rshift, gshift, bshift, rmask, gmask, bmask) \
do { \
if (a) { \
p = (r<<rshift) | (g<<gshift) | (b<<bshift); \
} \
} while (0)
#define SETPIXEL_BLEND(p, type, bpp, rshift, gshift, bshift, rmask, gmask, bmask) \
do { \
Uint8 sr = MUL(inva, SHIFTAND(p, rshift, rmask)) + (Uint16) r; \
Uint8 sg = MUL(inva, SHIFTAND(p, gshift, gmask)) + (Uint16) g; \
Uint8 sb = MUL(inva, SHIFTAND(p, bshift, bmask)) + (Uint16) b; \
p = (sr<<rshift) | (sg<<gshift) | (sb<<bshift); \
} while (0)
#define SETPIXEL_ADD(p, type, bpp, rshift, gshift, bshift, rmask, gmask, bmask) \
do { \
Uint16 sr = SHIFTAND(p, rshift, rmask) + (Uint16) r; \
Uint16 sg = SHIFTAND(p, gshift, gmask) + (Uint16) g; \
Uint16 sb = SHIFTAND(p, bshift, bmask) + (Uint16) b; \
if (sr>rmask) sr = rmask; \
if (sg>gmask) sg = gmask; \
if (sb>bmask) sb = bmask; \
p = (sr<<rshift) | (sg<<gshift) | (sb<<bshift); \
} while (0)
#define SETPIXEL_MOD(p, type, bpp, rshift, gshift, bshift, rmask, gmask, bmask) \
do { \
Uint8 sr = MUL(SHIFTAND(p, rshift, rmask), r); \
Uint8 sg = MUL(SHIFTAND(p, gshift, gmask), g); \
Uint8 sb = MUL(SHIFTAND(p, bshift, bmask), b); \
p = (sr<<rshift) | (sg<<gshift) | (sb<<bshift); \
} while (0)
#define SETPIXEL15_MASK(p) SETPIXEL_MASK(p, Uint16, 2, 10, 5, 0, 0x1f, 0x1f, 0x1f);
#define SETPIXEL15_BLEND(p) SETPIXEL_BLEND(p, Uint16, 2, 10, 5, 0, 0x1f, 0x1f, 0x1f);
#define SETPIXEL15_ADD(p) SETPIXEL_ADD(p, Uint16, 2, 10, 5, 0, 0x1f, 0x1f, 0x1f);
#define SETPIXEL15_MOD(p) SETPIXEL_MOD(p, Uint16, 2, 10, 5, 0, 0x1f, 0x1f, 0x1f);
#define SETPIXEL16_MASK(p) SETPIXEL_MASK(p, Uint16, 2, 11, 5, 0, 0x1f, 0x3f, 0x1f);
#define SETPIXEL16_BLEND(p) SETPIXEL_BLEND(p, Uint16, 2, 11, 5, 0, 0x1f, 0x3f, 0x1f);
#define SETPIXEL16_ADD(p) SETPIXEL_ADD(p, Uint16, 2, 11, 5, 0, 0x1f, 0x3f, 0x1f);
#define SETPIXEL16_MOD(p) SETPIXEL_MOD(p, Uint16, 2, 11, 5, 0, 0x1f, 0x3f, 0x1f);
#define SETPIXEL32_MASK(p) SETPIXEL_MASK(p, Uint32, 4, 16, 8, 0, 0xff, 0xff, 0xff);
#define SETPIXEL32_BLEND(p) SETPIXEL_BLEND(p, Uint32, 4, 16, 8, 0, 0xff, 0xff, 0xff);
#define SETPIXEL32_ADD(p) SETPIXEL_ADD(p, Uint32, 4, 16, 8, 0, 0xff, 0xff, 0xff);
#define SETPIXEL32_MOD(p) SETPIXEL_MOD(p, Uint32, 4, 16, 8, 0, 0xff, 0xff, 0xff);
#define BLENDRECT(type, op) \
do { \
int y = dstrect->y; \
int h = dstrect->h; \
while (h--) { \
type *pixel = (type *)(dst->pixels + y * dst->pitch + dstrect->x * dst->format->BytesPerPixel); \
int w = dstrect->w; \
while (w--) { \
op(*pixel); \
pixel++; \
} \
y++; \
} \
} while (0)
#include "SDL_draw.h"
int
SDL_BlendRect(SDL_Surface * dst, SDL_Rect * dstrect, int blendMode, Uint8 r,
Uint8 g, Uint8 b, Uint8 a)
static int
SDL_BlendRect_RGB555(SDL_Surface * dst, SDL_Rect * dstrect, int blendMode,
Uint8 r, Uint8 g, Uint8 b, Uint8 a)
{
Uint16 inva = 0xff - a;
/* This function doesn't work on surfaces < 8 bpp */
if (dst->format->BitsPerPixel < 8) {
SDL_SetError("SDL_BlendRect(): Unsupported surface format");
return (-1);
}
unsigned inva = 0xff - a;
/* If 'dstrect' == NULL, then fill the whole surface */
if (dstrect) {
/* Perform clipping */
if (!SDL_IntersectRect(dstrect, &dst->clip_rect, dstrect)) {
return (0);
}
} else {
dstrect = &dst->clip_rect;
switch (blendMode) {
case SDL_BLENDMODE_BLEND:
BLENDRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB555);
break;
case SDL_BLENDMODE_ADD:
BLENDRECT(Uint16, DRAW_SETPIXEL_ADD_RGB555);
break;
case SDL_BLENDMODE_MOD:
BLENDRECT(Uint16, DRAW_SETPIXEL_MOD_RGB555);
break;
default:
BLENDRECT(Uint16, DRAW_SETPIXEL_RGB555);
break;
}
return 0;
}
static int
SDL_BlendRect_RGB565(SDL_Surface * dst, SDL_Rect * dstrect, int blendMode,
Uint8 r, Uint8 g, Uint8 b, Uint8 a)
{
unsigned inva = 0xff - a;
if ((blendMode == SDL_BLENDMODE_BLEND)
|| (blendMode == SDL_BLENDMODE_ADD)) {
r = MUL(r, a);
g = MUL(g, a);
b = MUL(b, a);
}
switch (dst->format->BitsPerPixel) {
case 15:
switch (blendMode) {
case SDL_BLENDMODE_MASK:
BLENDRECT(Uint16, SETPIXEL15_MASK);
break;
case SDL_BLENDMODE_BLEND:
BLENDRECT(Uint16, SETPIXEL15_BLEND);
BLENDRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB565);
break;
case SDL_BLENDMODE_ADD:
BLENDRECT(Uint16, SETPIXEL15_ADD);
BLENDRECT(Uint16, DRAW_SETPIXEL_ADD_RGB565);
break;
case SDL_BLENDMODE_MOD:
BLENDRECT(Uint16, SETPIXEL15_MOD);
BLENDRECT(Uint16, DRAW_SETPIXEL_MOD_RGB565);
break;
}
default:
BLENDRECT(Uint16, DRAW_SETPIXEL_RGB565);
break;
case 16:
}
return 0;
}
static int
SDL_BlendRect_RGB888(SDL_Surface * dst, SDL_Rect * dstrect, int blendMode,
Uint8 r, Uint8 g, Uint8 b, Uint8 a)
{
unsigned inva = 0xff - a;
switch (blendMode) {
case SDL_BLENDMODE_MASK:
BLENDRECT(Uint16, SETPIXEL16_MASK);
case SDL_BLENDMODE_BLEND:
BLENDRECT(Uint32, DRAW_SETPIXEL_BLEND_RGB888);
break;
case SDL_BLENDMODE_ADD:
BLENDRECT(Uint32, DRAW_SETPIXEL_ADD_RGB888);
break;
case SDL_BLENDMODE_MOD:
BLENDRECT(Uint32, DRAW_SETPIXEL_MOD_RGB888);
break;
default:
BLENDRECT(Uint32, DRAW_SETPIXEL_RGB888);
break;
}
return 0;
}
static int
SDL_BlendRect_RGB(SDL_Surface * dst, SDL_Rect * dstrect, int 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:
BLENDRECT(Uint16, SETPIXEL16_BLEND);
BLENDRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB);
break;
case SDL_BLENDMODE_ADD:
BLENDRECT(Uint16, SETPIXEL16_ADD);
BLENDRECT(Uint16, DRAW_SETPIXEL_ADD_RGB);
break;
case SDL_BLENDMODE_MOD:
BLENDRECT(Uint16, SETPIXEL16_MOD);
BLENDRECT(Uint16, DRAW_SETPIXEL_MOD_RGB);
break;
default:
BLENDRECT(Uint16, DRAW_SETPIXEL_RGB);
break;
}
return 0;
case 4:
switch (blendMode) {
case SDL_BLENDMODE_BLEND:
BLENDRECT(Uint32, DRAW_SETPIXEL_BLEND_RGB);
break;
case 24:
case 32:
if (dst->format->BytesPerPixel != 4) {
case SDL_BLENDMODE_ADD:
BLENDRECT(Uint32, DRAW_SETPIXEL_ADD_RGB);
break;
case SDL_BLENDMODE_MOD:
BLENDRECT(Uint32, DRAW_SETPIXEL_MOD_RGB);
break;
default:
BLENDRECT(Uint32, DRAW_SETPIXEL_RGB);
break;
}
return 0;
default:
SDL_Unsupported();
return -1;
}
}
static int
SDL_BlendRect_RGBA(SDL_Surface * dst, SDL_Rect * dstrect, int 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_MASK:
BLENDRECT(Uint32, SETPIXEL32_MASK);
break;
case SDL_BLENDMODE_BLEND:
BLENDRECT(Uint32, SETPIXEL32_BLEND);
BLENDRECT(Uint32, DRAW_SETPIXEL_BLEND_RGBA);
break;
case SDL_BLENDMODE_ADD:
BLENDRECT(Uint32, SETPIXEL32_ADD);
BLENDRECT(Uint32, DRAW_SETPIXEL_ADD_RGBA);
break;
case SDL_BLENDMODE_MOD:
BLENDRECT(Uint32, SETPIXEL32_MOD);
BLENDRECT(Uint32, DRAW_SETPIXEL_MOD_RGBA);
break;
}
default:
BLENDRECT(Uint32, DRAW_SETPIXEL_RGBA);
break;
}
return 0;
default:
SDL_Unsupported();
return -1;
}
return 0;
return -1;
}
int
SDL_BlendRect(SDL_Surface * dst, SDL_Rect * dstrect, int blendMode, Uint8 r,
Uint8 g, Uint8 b, Uint8 a)
{
SDL_PixelFormat *fmt = dst->format;
/* This function doesn't work on surfaces < 8 bpp */
if (fmt->BitsPerPixel < 8) {
SDL_SetError("SDL_BlendRect(): Unsupported surface format");
return (-1);
}
/* If 'dstrect' == NULL, then fill the whole surface */
if (dstrect) {
/* Perform clipping */
if (!SDL_IntersectRect(dstrect, &dst->clip_rect, dstrect)) {
return (0);
}
} else {
dstrect = &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 (fmt->BitsPerPixel) {
case 15:
switch (fmt->Rmask) {
case 0x7C00:
return SDL_BlendRect_RGB555(dst, dstrect, blendMode, r, g, b, a);
}
break;
case 16:
switch (fmt->Rmask) {
case 0xF800:
return SDL_BlendRect_RGB565(dst, dstrect, blendMode, r, g, b, a);
}
break;
case 32:
switch (fmt->Rmask) {
case 0x00FF0000:
if (!fmt->Amask) {
return SDL_BlendRect_RGB888(dst, dstrect, blendMode, r, g, b,
a);
}
break;
}
default:
break;
}
if (!fmt->Amask) {
return SDL_BlendRect_RGB(dst, dstrect, blendMode, r, g, b, a);
} else {
return SDL_BlendRect_RGBA(dst, dstrect, blendMode, r, g, b, a);
}
}
/* vi: set ts=4 sw=4 expandtab: */
src/video/SDL_blit.h
View file @ d95e51d2
......@@ -39,6 +39,7 @@
#include "SDL_cpuinfo.h"
#include "SDL_endian.h"
#include "SDL_video.h"
/* SDL blit copy flags */
#define SDL_COPY_MODULATE_COLOR 0x00000001
......@@ -575,4 +576,5 @@ do { \
#endif
#endif /* _SDL_blit_h */
/* vi: set ts=4 sw=4 expandtab: */
src/video/SDL_draw.h 0 → 100644
View file @ d95e51d2
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2009 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_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_SETPIXEL_MOD(getpixel, setpixel) \
do { \
unsigned sr, sg, sb, sa; sa; \
getpixel; \
sr = DRAW_MUL(sr, r); \
sg = DRAW_MUL(sg, g); \
sb = DRAW_MUL(sb, b); \
setpixel; \
} while (0)
#define DRAW_SETPIXELXY(x, y, type, bpp, op) \
do { \
type *pixel = (type *)(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_SETPIXEL_MOD_RGB555 \
DRAW_SETPIXEL_MOD(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_SETPIXELXY_MOD_RGB555(x, y) \
DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_MOD_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_SETPIXEL_MOD_RGB565 \
DRAW_SETPIXEL_MOD(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_SETPIXELXY_MOD_RGB565(x, y) \
DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_MOD_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_SETPIXEL_MOD_RGB888 \
DRAW_SETPIXEL_MOD(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_SETPIXELXY_MOD_RGB888(x, y) \
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_MOD_RGB888)
/*
* 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_SETPIXEL_MOD_RGB \
DRAW_SETPIXEL_MOD(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_SETPIXELXY2_MOD_RGB(x, y) \
DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_MOD_RGB)
#define DRAW_SETPIXELXY4_MOD_RGB(x, y) \
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_MOD_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_SETPIXEL_MOD_RGBA \
DRAW_SETPIXEL_MOD(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 DRAW_SETPIXELXY4_MOD_RGBA(x, y) \
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_MOD_RGBA)
/*
* Define line drawing macro
*/
#define ABS(_x) ((_x) < 0 ? -(_x) : (_x))
#define SWAP(_x, _y) do { int tmp; tmp = _x; _x = _y; _y = tmp; } while (0)
#define BRESENHAM(x0, y0, x1, y1, op) \
{ \
int deltax, deltay, steep, error, xstep, ystep, x, y; \
\
deltax = ABS(x1 - x0); \
deltay = ABS(y1 - y0); \
steep = (deltay > deltax); \
if (steep) { \
SWAP(x0, y0); \
SWAP(x1, y1); \
SWAP(deltax, deltay); \
} \
error = (x1 - x0) / 2; \
y = y0; \
if (x0 > x1) { \
xstep = -1; \
} else { \
xstep = 1; \
} \
if (y0 < y1) { \
ystep = 1; \
} else { \
ystep = -1; \
} \
if (!steep) { \
for (x = x0; x != x1; x += xstep) { \
op(x, y); \
error -= deltay; \
if (error < 0) { \
y += ystep; \
error += deltax; \
} \
} \
} else { \
for (x = x0; x != x1; x += xstep) { \
op(y, x); \
error -= deltay; \
if (error < 0) { \
y += ystep; \
error += deltax; \
} \
} \
} \
}
/*
* Define blend fill macro
*/
#define BLENDRECT(type, op) \
do { \
int w; \
int width = dstrect->w; \
int height = dstrect->h; \
int pitch = (dst->pitch / dst->format->BytesPerPixel); \
int skip = pitch - width; \
type *pixel = (type *)dst->pixels + dstrect->y * pitch + dstrect->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)
/*
* Define blend line macro
*/
/* vi: set ts=4 sw=4 expandtab: */
src/video/SDL_drawline.c
View file @ d95e51d2
......@@ -21,64 +21,14 @@
*/
#include "SDL_config.h"
#include "SDL_video.h"
#include "SDL_blit.h"
#define ABS(_x) ((_x) < 0 ? -(_x) : (_x))
#define SWAP(_x, _y) do { int tmp; tmp = _x; _x = _y; _y = tmp; } while (0)
#define BRESENHAM(x0, y0, x1, y1, op, color) \
{ \
int deltax, deltay, steep, error, xstep, ystep, x, y; \
\
deltax = ABS(x1 - x0); \
deltay = ABS(y1 - y0); \
steep = (deltay > deltax); \
if (steep) { \
SWAP(x0, y0); \
SWAP(x1, y1); \
SWAP(deltax, deltay); \
} \
error = (x1 - x0) / 2; \
y = y0; \
if (x0 > x1) { \
xstep = -1; \
} else { \
xstep = 1; \
} \
if (y0 < y1) { \
ystep = 1; \
} else { \
ystep = -1; \
} \
if (!steep) { \
for (x = x0; x != x1; x += xstep) { \
op(x, y, color); \
error -= deltay; \
if (error < 0) { \
y += ystep; \
error += deltax; \
} \
} \
} else { \
for (x = x0; x != x1; x += xstep) { \
op(y, x, color); \
error -= deltay; \
if (error < 0) { \
y += ystep; \
error += deltax; \
} \
} \
} \
}
#include "SDL_draw.h"
#define SETPIXEL(x, y, type, bpp, color) \
*(type *)(dst->pixels + y * dst->pitch + x * bpp) = (type) color
#define SETPIXEL1(x, y, color) SETPIXEL(x, y, Uint8, 1, color);
#define SETPIXEL2(x, y, color) SETPIXEL(x, y, Uint16, 2, color);
#define SETPIXEL4(x, y, color) SETPIXEL(x, y, Uint32, 4, color);
#define SETPIXEL1(x, y) SETPIXEL(x, y, Uint8, 1, color);
#define SETPIXEL2(x, y) SETPIXEL(x, y, Uint16, 2, color);
#define SETPIXEL4(x, y) SETPIXEL(x, y, Uint32, 4, color);
SDL_DrawLine(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color)
{
......@@ -97,16 +47,16 @@ SDL_DrawLine(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color)
switch (dst->format->BytesPerPixel) {
case 1:
BRESENHAM(x1, y1, x2, y2, SETPIXEL1, color);
BRESENHAM(x1, y1, x2, y2, SETPIXEL1);
break;
case 2:
BRESENHAM(x1, y1, x2, y2, SETPIXEL2, color);
BRESENHAM(x1, y1, x2, y2, SETPIXEL2);
break;
case 3:
SDL_Unsupported();
return -1;
case 4:
BRESENHAM(x1, y1, x2, y2, SETPIXEL4, color);
BRESENHAM(x1, y1, x2, y2, SETPIXEL4);
break;
}
return 0;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment