diff options
Diffstat (limited to 'graphics/sdl/raster.c')
| -rw-r--r-- | graphics/sdl/raster.c | 2022 |
1 files changed, 2022 insertions, 0 deletions
diff --git a/graphics/sdl/raster.c b/graphics/sdl/raster.c new file mode 100644 index 00000000..dd54cd4a --- /dev/null +++ b/graphics/sdl/raster.c @@ -0,0 +1,2022 @@ +/* raster.c -- line/rect/circle/poly rasterization + + copyright (c) 2008 bryan rittmeyer <bryanr@bryanr.org> + license: LGPLv2 + + based on SDL_gfx (c) A. Schiffler + and SGE (c)1999-2003 Anders Lindström + + + added filled anti-aliased polygons + + fixed some bugs and improved performance + + revision history + 2008-07-05 initial + 2008-07-06 aacircle +*/ + + +#include <math.h> + +#include "raster.h" + +#undef DEBUG +#undef PARANOID + + +/* raster_rect */ + +static inline void raster_rect_inline(SDL_Surface *dst, int16_t x1, int16_t y1, int16_t w, int16_t h, uint32_t color) +{ + /* sge */ + SDL_Rect rect; + +#if 1 + if((w <= 0) || (h <= 0)) + { + return; + } + +#if 0 + if(x1 < 0) + { + if((x1 + w) < 0) + { + return; + } + else + { + w = w + x1; + x1 = 0; + } + } + if(y1 < 0) + { + if((y1 + h) < 0) + { + return; + } + else + { + h = h + y1; + y1 = 0; + } + } + + if(x1 + w >= dst->w) + { + w = dst->w - x1; + } + if(y1 + h >= dst->h) + { + h = dst->h - y1; + } +#endif + + rect.x = x1; + rect.y = y1; + rect.w = w; + rect.h = h; + + /* will clip internally */ + SDL_FillRect(dst, &rect, color); + +#else + + x2 = x1 + w; + y2 = y1 + h; + + /* + * Order coordinates to ensure that + * x1<=x2 and y1<=y2 + */ + if (x1 > x2) { + tmp = x1; + x1 = x2; + x2 = tmp; + } + if (y1 > y2) { + tmp = y1; + y1 = y2; + y2 = tmp; + } + + /* + * Get clipping boundary and + * check visibility + */ + left = dst->clip_rect.x; + if (x2<left) { + return(0); + } + right = dst->clip_rect.x + dst->clip_rect.w - 1; + if (x1>right) { + return(0); + } + top = dst->clip_rect.y; + if (y2<top) { + return(0); + } + bottom = dst->clip_rect.y + dst->clip_rect.h - 1; + if (y1>bottom) { + return(0); + } + + /* Clip all points */ + if (x1<left) { + x1=left; + } else if (x1>right) { + x1=right; + } + if (x2<left) { + x2=left; + } else if (x2>right) { + x2=right; + } + if (y1<top) { + y1=top; + } else if (y1>bottom) { + y1=bottom; + } + if (y2<top) { + y2=top; + } else if (y2>bottom) { + y2=bottom; + } + +#if 0 + /* + * Test for special cases of straight line or single point + */ + if (x1 == x2) { + if (y1 == y2) { + return (pixelColor(dst, x1, y1, color)); + } else { + return (vlineColor(dst, x1, y1, y2, color)); + } + } + if (y1 == y2) { + return (hlineColor(dst, x1, x2, y1, color)); + } +#endif + + /* + * Calculate width&height + */ + w = x2 - x1; + h = y2 - y1; + + /* + * No alpha-blending required + */ + +#if 0 + /* + * Setup color + */ + colorptr = (Uint8 *) & color; + if (SDL_BYTEORDER == SDL_BIG_ENDIAN) { + color = SDL_MapRGBA(dst->format, colorptr[0], colorptr[1], colorptr[2], colorptr[3]); + } else { + color = SDL_MapRGBA(dst->format, colorptr[3], colorptr[2], colorptr[1], colorptr[0]); + } +#endif + + /* + * Lock surface + */ + SDL_LockSurface(dst); + + /* + * More variable setup + */ + dx = w; + dy = h; + pixx = dst->format->BytesPerPixel; + pixy = dst->pitch; + pixel = ((Uint8 *) dst->pixels) + pixx * (int) x1 + pixy * (int) y1; + pixellast = pixel + pixx * dx + pixy * dy; + dx++; + + /* + * Draw + */ + switch (dst->format->BytesPerPixel) { + case 1: + for (; pixel <= pixellast; pixel += pixy) { + memset(pixel, (Uint8) color, dx); + } + break; + case 2: + pixy -= (pixx * dx); + for (; pixel <= pixellast; pixel += pixy) { + for (x = 0; x < dx; x++) { + *(Uint16*) pixel = color; + pixel += pixx; + } + } + break; + case 3: + pixy -= (pixx * dx); + for (; pixel <= pixellast; pixel += pixy) { + for (x = 0; x < dx; x++) { + if (SDL_BYTEORDER == SDL_BIG_ENDIAN) { + pixel[0] = (color >> 16) & 0xff; + pixel[1] = (color >> 8) & 0xff; + pixel[2] = color & 0xff; + } else { + pixel[0] = color & 0xff; + pixel[1] = (color >> 8) & 0xff; + pixel[2] = (color >> 16) & 0xff; + } + pixel += pixx; + } + } + break; + default: /* case 4 */ + pixy -= (pixx * dx); + for (; pixel <= pixellast; pixel += pixy) { + for (x = 0; x < dx; x++) { + *(Uint32 *) pixel = color; + pixel += pixx; + } + } + break; + } + + /* + * Unlock surface + */ + SDL_UnlockSurface(dst); + +#endif +} + +void raster_rect(SDL_Surface *s, int16_t x, int16_t y, int16_t w, int16_t h, uint32_t col) +{ + raster_rect_inline(s, x, y, w, h, col); +} + +#define raster_rect_inline raster_rect + + +/* raster :: pixel */ + +#define MODIFIED_ALPHA_PIXEL_ROUTINE + + +#define clip_xmin(surface) surface->clip_rect.x +#define clip_xmax(surface) surface->clip_rect.x+surface->clip_rect.w-1 +#define clip_ymin(surface) surface->clip_rect.y +#define clip_ymax(surface) surface->clip_rect.y+surface->clip_rect.h-1 + + +static void raster_PutPixel(SDL_Surface *surface, Sint16 x, Sint16 y, Uint32 color) +{ + if(x>=clip_xmin(surface) && x<=clip_xmax(surface) && y>=clip_ymin(surface) && y<=clip_ymax(surface)){ + switch (surface->format->BytesPerPixel) { + case 1: { /* Assuming 8-bpp */ + *((Uint8 *)surface->pixels + y*surface->pitch + x) = color; + } + break; + + case 2: { /* Probably 15-bpp or 16-bpp */ + *((Uint16 *)surface->pixels + y*surface->pitch/2 + x) = color; + } + break; + + case 3: { /* Slow 24-bpp mode, usually not used */ + Uint8 *pix = (Uint8 *)surface->pixels + y * surface->pitch + x*3; + + /* Gack - slow, but endian correct */ + *(pix+surface->format->Rshift/8) = color>>surface->format->Rshift; + *(pix+surface->format->Gshift/8) = color>>surface->format->Gshift; + *(pix+surface->format->Bshift/8) = color>>surface->format->Bshift; + *(pix+surface->format->Ashift/8) = color>>surface->format->Ashift; + } + break; + + case 4: { /* Probably 32-bpp */ + *((Uint32 *)surface->pixels + y*surface->pitch/4 + x) = color; + } + break; + } + } +} + +/* PutPixel routine with alpha blending, input color in destination format */ + +/* New, faster routine - default blending pixel */ + +static void raster_PutPixelAlpha(SDL_Surface * surface, Sint16 x, Sint16 y, Uint32 color, Uint8 alpha) +{ + /* sdl-gfx */ + Uint32 Rmask = surface->format->Rmask, Gmask = + surface->format->Gmask, Bmask = surface->format->Bmask, Amask = surface->format->Amask; + Uint32 R = 0, G = 0, B = 0, A = 0; + + if (x >= clip_xmin(surface) && x <= clip_xmax(surface) + && y >= clip_ymin(surface) && y <= clip_ymax(surface)) { + + switch (surface->format->BytesPerPixel) { + case 1:{ /* Assuming 8-bpp */ + if (alpha == 255) { + *((Uint8 *) surface->pixels + y * surface->pitch + x) = color; + } else { + Uint8 *pixel = (Uint8 *) surface->pixels + y * surface->pitch + x; + + Uint8 dR = surface->format->palette->colors[*pixel].r; + Uint8 dG = surface->format->palette->colors[*pixel].g; + Uint8 dB = surface->format->palette->colors[*pixel].b; + Uint8 sR = surface->format->palette->colors[color].r; + Uint8 sG = surface->format->palette->colors[color].g; + Uint8 sB = surface->format->palette->colors[color].b; + + dR = dR + ((sR - dR) * alpha >> 8); + dG = dG + ((sG - dG) * alpha >> 8); + dB = dB + ((sB - dB) * alpha >> 8); + + *pixel = SDL_MapRGB(surface->format, dR, dG, dB); + } + } + break; + + case 2:{ /* Probably 15-bpp or 16-bpp */ + if (alpha == 255) { + *((Uint16 *) surface->pixels + y * surface->pitch / 2 + x) = color; + } else { + Uint16 *pixel = (Uint16 *) surface->pixels + y * surface->pitch / 2 + x; + Uint32 dc = *pixel; + + R = ((dc & Rmask) + (((color & Rmask) - (dc & Rmask)) * alpha >> 8)) & Rmask; + G = ((dc & Gmask) + (((color & Gmask) - (dc & Gmask)) * alpha >> 8)) & Gmask; + B = ((dc & Bmask) + (((color & Bmask) - (dc & Bmask)) * alpha >> 8)) & Bmask; + if (Amask) + A = ((dc & Amask) + (((color & Amask) - (dc & Amask)) * alpha >> 8)) & Amask; + + *pixel = R | G | B | A; + } + } + break; + + case 3:{ /* Slow 24-bpp mode, usually not used */ + Uint8 *pix = (Uint8 *) surface->pixels + y * surface->pitch + x * 3; + Uint8 rshift8 = surface->format->Rshift / 8; + Uint8 gshift8 = surface->format->Gshift / 8; + Uint8 bshift8 = surface->format->Bshift / 8; + Uint8 ashift8 = surface->format->Ashift / 8; + + + if (alpha == 255) { + *(pix + rshift8) = color >> surface->format->Rshift; + *(pix + gshift8) = color >> surface->format->Gshift; + *(pix + bshift8) = color >> surface->format->Bshift; + *(pix + ashift8) = color >> surface->format->Ashift; + } else { + Uint8 dR, dG, dB, dA = 0; + Uint8 sR, sG, sB, sA = 0; + + pix = (Uint8 *) surface->pixels + y * surface->pitch + x * 3; + + dR = *((pix) + rshift8); + dG = *((pix) + gshift8); + dB = *((pix) + bshift8); + dA = *((pix) + ashift8); + + sR = (color >> surface->format->Rshift) & 0xff; + sG = (color >> surface->format->Gshift) & 0xff; + sB = (color >> surface->format->Bshift) & 0xff; + sA = (color >> surface->format->Ashift) & 0xff; + + dR = dR + ((sR - dR) * alpha >> 8); + dG = dG + ((sG - dG) * alpha >> 8); + dB = dB + ((sB - dB) * alpha >> 8); + dA = dA + ((sA - dA) * alpha >> 8); + + *((pix) + rshift8) = dR; + *((pix) + gshift8) = dG; + *((pix) + bshift8) = dB; + *((pix) + ashift8) = dA; + } + } + break; + +#ifdef ORIGINAL_ALPHA_PIXEL_ROUTINE + + case 4:{ /* Probably :-) 32-bpp */ + if (alpha == 255) { + *((Uint32 *) surface->pixels + y * surface->pitch / 4 + x) = color; + } else { + Uint32 Rshift, Gshift, Bshift, Ashift; + Uint32 *pixel = (Uint32 *) surface->pixels + y * surface->pitch / 4 + x; + Uint32 dc = *pixel; + + Rshift = surface->format->Rshift; + Gshift = surface->format->Gshift; + Bshift = surface->format->Bshift; + Ashift = surface->format->Ashift; + + R = ((dc & Rmask) + (((((color & Rmask) - (dc & Rmask)) >> Rshift) * alpha >> 8) << Rshift)) & Rmask; + G = ((dc & Gmask) + (((((color & Gmask) - (dc & Gmask)) >> Gshift) * alpha >> 8) << Gshift)) & Gmask; + B = ((dc & Bmask) + (((((color & Bmask) - (dc & Bmask)) >> Bshift) * alpha >> 8) << Bshift)) & Bmask; + if (Amask) + A = ((dc & Amask) + (((((color & Amask) - (dc & Amask)) >> Ashift) * alpha >> 8) << Ashift)) & Amask; + + *pixel = R | G | B | A; + } + } + break; +#endif + +#ifdef MODIFIED_ALPHA_PIXEL_ROUTINE + + case 4:{ /* Probably :-) 32-bpp */ + if (alpha == 255) { + *((Uint32 *) surface->pixels + y * surface->pitch / 4 + x) = color; + } else { + Uint32 Rshift, Gshift, Bshift, Ashift; + Uint32 *pixel = (Uint32 *) surface->pixels + y * surface->pitch / 4 + x; + Uint32 dc = *pixel; + Uint32 dR = (color & Rmask), dG = (color & Gmask), dB = (color & Bmask); + Uint32 surfaceAlpha, preMultR, preMultG, preMultB; + Uint32 aTmp; + + Rshift = surface->format->Rshift; + Gshift = surface->format->Gshift; + Bshift = surface->format->Bshift; + Ashift = surface->format->Ashift; + + preMultR = (alpha * (dR>>Rshift)); + preMultG = (alpha * (dG>>Gshift)); + preMultB = (alpha * (dB>>Bshift)); + + surfaceAlpha = ((dc & Amask) >> Ashift); + aTmp = (255 - alpha); + if ((A = 255 - ((aTmp * (255 - surfaceAlpha)) >> 8 ))) { + aTmp *= surfaceAlpha; + R = (preMultR + ((aTmp * ((dc & Rmask) >> Rshift)) >> 8)) / A << Rshift & Rmask; + G = (preMultG + ((aTmp * ((dc & Gmask) >> Gshift)) >> 8)) / A << Gshift & Gmask; + B = (preMultB + ((aTmp * ((dc & Bmask) >> Bshift)) >> 8)) / A << Bshift & Bmask; + } + *pixel = R | G | B | (A << Ashift & Amask); + + } + } + break; +#endif + } + } +} + + +/* FIXME: eliminate these 2 functions */ + +static int raster_pixelColorNolock(SDL_Surface * dst, Sint16 x, Sint16 y, Uint32 color) +{ + int result = 0; + +#if 0 + /* + * Setup color + */ + alpha = color & 0x000000ff; + mcolor = + SDL_MapRGBA(dst->format, (color & 0xff000000) >> 24, + (color & 0x00ff0000) >> 16, (color & 0x0000ff00) >> 8, alpha); +#endif + + /* + * Draw + */ + raster_PutPixel(dst, x, y, color); + + return (result); +} + + +/* Pixel - using alpha weight on color for AA-drawing - no locking */ + +static int raster_pixelColorWeightNolock(SDL_Surface * dst, Sint16 x, Sint16 y, Uint32 color, Uint32 weight) +{ +#if 0 + Uint32 a; + + /* + * Get alpha + */ + a = (color & (Uint32) 0x000000ff); + + /* + * Modify Alpha by weight + */ + a = ((a * weight) >> 8); +#endif + + raster_PutPixelAlpha(dst, x, y, color, weight); + + return 0; +} + + +/* raster :: line */ + + + +static inline void raster_hline(SDL_Surface * dst, Sint16 x1, Sint16 x2, Sint16 y, Uint32 color) +{ +#if 1 + SDL_Rect l; + + /* sge */ + if(x1>x2){Sint16 tmp=x1; x1=x2; x2=tmp;} + + l.x=x1; l.y=y; l.w=x2-x1+1; l.h=1; + + SDL_FillRect(dst, &l, color); + +#else + /* sdl_gfx */ + Sint16 left, right, top, bottom; + Uint8 *pixel, *pixellast; + int dx; + int pixx, pixy; + Sint16 w; + Sint16 xtmp; + int result = -1; +#if 0 + int i; + union + { + double d; + uint16_t col[4]; + } doub; + + for(i = 0; i < 4; i++) + { + doub.col[i] = color; + } +#endif + + /* + * Check visibility of clipping rectangle + */ + if ((dst->clip_rect.w==0) || (dst->clip_rect.h==0)) { + return(0); + } + + /* + * Swap x1, x2 if required to ensure x1<=x2 + */ + if (x1 > x2) { + xtmp = x1; + x1 = x2; + x2 = xtmp; + } + + /* + * Get clipping boundary and + * check visibility of hline + */ + left = dst->clip_rect.x; + if (x2<left) { + return(0); + } + right = dst->clip_rect.x + dst->clip_rect.w - 1; + if (x1>right) { + return(0); + } + top = dst->clip_rect.y; + bottom = dst->clip_rect.y + dst->clip_rect.h - 1; + if ((y<top) || (y>bottom)) { + return (0); + } + + /* + * Clip x + */ + if (x1 < left) { + x1 = left; + } + if (x2 > right) { + x2 = right; + } + + /* + * Calculate width + */ + w = x2 - x1; + +#if 0 + printf("raster_hline %d %d %d %d\n", x1, x2, y, w); +#endif + + /* + * Lock surface + */ + if (SDL_MUSTLOCK(dst)) { + SDL_LockSurface(dst); + } + + /* + * More variable setup + */ + dx = w; + pixx = dst->format->BytesPerPixel; + pixy = dst->pitch; + pixel = ((Uint8 *) dst->pixels) + pixx * (int) x1 + pixy * (int) y; + + /* + * Draw + */ + switch (dst->format->BytesPerPixel) { + case 1: + memset(pixel, color, dx); + break; + case 2: + pixellast = pixel + dx + dx; +#if 0 + for (; (pixel+3) <= pixellast; pixel += 4*pixx) + { + *(double *)pixel = doub.d; + } +#endif + for (; pixel <= pixellast; pixel += pixx) { + *(Uint16 *) pixel = color; + } + break; + case 3: + pixellast = pixel + dx + dx + dx; + for (; pixel <= pixellast; pixel += pixx) { + if (SDL_BYTEORDER == SDL_BIG_ENDIAN) { + pixel[0] = (color >> 16) & 0xff; + pixel[1] = (color >> 8) & 0xff; + pixel[2] = color & 0xff; + } else { + pixel[0] = color & 0xff; + pixel[1] = (color >> 8) & 0xff; + pixel[2] = (color >> 16) & 0xff; + } + } + break; + default: /* case 4 */ + dx = dx + dx; + pixellast = pixel + dx + dx; + for (; pixel <= pixellast; pixel += pixx) { + *(Uint32 *) pixel = color; + } + break; + } + + /* + * Unlock surface + */ + if (SDL_MUSTLOCK(dst)) { + SDL_UnlockSurface(dst); + } + + /* + * Set result code + */ + result = 0; + + return (result); +#endif +} + +static void raster_vline(SDL_Surface *dst, Sint16 x, Sint16 y1, Sint16 y2, Uint32 color) +{ + SDL_Rect l; + + if(y1>y2){Sint16 tmp=y1; y1=y2; y2=tmp;} + + l.x=x; l.y=y1; l.w=1; l.h=y2-y1+1; + + SDL_FillRect(dst, &l, color); +} + + + +/* raster_line */ +#define CLIP_LEFT_EDGE 0x1 +#define CLIP_RIGHT_EDGE 0x2 +#define CLIP_BOTTOM_EDGE 0x4 +#define CLIP_TOP_EDGE 0x8 +#define CLIP_INSIDE(a) (!a) +#define CLIP_REJECT(a,b) (a&b) +#define CLIP_ACCEPT(a,b) (!(a|b)) + +static int clipEncode(Sint16 x, Sint16 y, Sint16 left, Sint16 top, Sint16 right, Sint16 bottom) +{ + int code = 0; + + if (x < left) { + code |= CLIP_LEFT_EDGE; + } else if (x > right) { + code |= CLIP_RIGHT_EDGE; + } + if (y < top) { + code |= CLIP_TOP_EDGE; + } else if (y > bottom) { + code |= CLIP_BOTTOM_EDGE; + } + return code; +} + +static int clipLine(SDL_Surface * dst, Sint16 * x1, Sint16 * y1, Sint16 * x2, Sint16 * y2) +{ + Sint16 left, right, top, bottom; + int code1, code2; + int draw = 0; + Sint16 swaptmp; + float m; + + /* + * Get clipping boundary + */ + left = dst->clip_rect.x; + right = dst->clip_rect.x + dst->clip_rect.w - 1; + top = dst->clip_rect.y; + bottom = dst->clip_rect.y + dst->clip_rect.h - 1; + + while (1) { + code1 = clipEncode(*x1, *y1, left, top, right, bottom); + code2 = clipEncode(*x2, *y2, left, top, right, bottom); + if (CLIP_ACCEPT(code1, code2)) { + draw = 1; + break; + } else if (CLIP_REJECT(code1, code2)) + break; + else { + if (CLIP_INSIDE(code1)) { + swaptmp = *x2; + *x2 = *x1; + *x1 = swaptmp; + swaptmp = *y2; + *y2 = *y1; + *y1 = swaptmp; + swaptmp = code2; + code2 = code1; + code1 = swaptmp; + } + if (*x2 != *x1) { + m = (*y2 - *y1) / (float) (*x2 - *x1); + } else { + m = 1.0f; + } + if (code1 & CLIP_LEFT_EDGE) { + *y1 += (Sint16) ((left - *x1) * m); + *x1 = left; + } else if (code1 & CLIP_RIGHT_EDGE) { + *y1 += (Sint16) ((right - *x1) * m); + *x1 = right; + } else if (code1 & CLIP_BOTTOM_EDGE) { + if (*x2 != *x1) { + *x1 += (Sint16) ((bottom - *y1) / m); + } + *y1 = bottom; + } else if (code1 & CLIP_TOP_EDGE) { + if (*x2 != *x1) { + *x1 += (Sint16) ((top - *y1) / m); + } + *y1 = top; + } + } + } + + return draw; +} + + +void raster_line(SDL_Surface *dst, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint32_t color) +{ + /* sdl-gfx */ + int pixx, pixy; + int x, y; + int dx, dy; + int sx, sy; + int swaptmp; + Uint8 *pixel; + + /* + * Clip line and test if we have to draw + */ + if (!(clipLine(dst, &x1, &y1, &x2, &y2))) { + return; + } + + /* + * Test for special cases of straight lines or single point + */ + if (x1 == x2) { + if (y1 < y2) { + raster_vline(dst, x1, y1, y2, color); + return; + } else if (y1 > y2) { + raster_vline(dst, x1, y2, y1, color); + return; + } else { + raster_PutPixel(dst, x1, y1, color); + return; + } + } + if (y1 == y2) { + if (x1 < x2) { + raster_hline(dst, x1, x2, y1, color); + return; + } else if (x1 > x2) { + raster_hline(dst, x2, x1, y1, color); + return; + } + } + + + /* + * Variable setup + */ + dx = x2 - x1; + dy = y2 - y1; + sx = (dx >= 0) ? 1 : -1; + sy = (dy >= 0) ? 1 : -1; + + /* Lock surface */ + if (SDL_MUSTLOCK(dst)) { + if (SDL_LockSurface(dst) < 0) { + return; + } + } + + /* + * No alpha blending - use fast pixel routines + */ + +#if 0 + /* + * Setup color + */ + colorptr = (Uint8 *) & color; + if (SDL_BYTEORDER == SDL_BIG_ENDIAN) { + color = SDL_MapRGBA(dst->format, colorptr[0], colorptr[1], colorptr[2], colorptr[3]); + } else { + color = SDL_MapRGBA(dst->format, colorptr[3], colorptr[2], colorptr[1], colorptr[0]); + } +#endif + + /* + * More variable setup + */ + dx = sx * dx + 1; + dy = sy * dy + 1; + pixx = dst->format->BytesPerPixel; + pixy = dst->pitch; + pixel = ((Uint8 *) dst->pixels) + pixx * (int) x1 + pixy * (int) y1; + pixx *= sx; + pixy *= sy; + if (dx < dy) { + swaptmp = dx; + dx = dy; + dy = swaptmp; + swaptmp = pixx; + pixx = pixy; + pixy = swaptmp; + } + + /* + * Draw + */ + x = 0; + y = 0; + switch (dst->format->BytesPerPixel) { + case 1: + for (; x < dx; x++, pixel += pixx) { + *pixel = color; + y += dy; + if (y >= dx) { + y -= dx; + pixel += pixy; + } + } + break; + case 2: + for (; x < dx; x++, pixel += pixx) { + *(Uint16 *) pixel = color; + y += dy; + if (y >= dx) { + y -= dx; + pixel += pixy; + } + } + break; + case 3: + for (; x < dx; x++, pixel += pixx) { + if (SDL_BYTEORDER == SDL_BIG_ENDIAN) { + pixel[0] = (color >> 16) & 0xff; + pixel[1] = (color >> 8) & 0xff; + pixel[2] = color & 0xff; + } else { + pixel[0] = color & 0xff; + pixel[1] = (color >> 8) & 0xff; + pixel[2] = (color >> 16) & 0xff; + } + y += dy; + if (y >= dx) { + y -= dx; + pixel += pixy; + } + } + break; + default: /* case 4 */ + for (; x < dx; x++, pixel += pixx) { + *(Uint32 *) pixel = color; + y += dy; + if (y >= dx) { + y -= dx; + pixel += pixy; + } + } + break; + } + + /* Unlock surface */ + if (SDL_MUSTLOCK(dst)) { + SDL_UnlockSurface(dst); + } + + return; +} + + +#define AAlevels 256 +#define AAbits 8 + +static void raster_aalineColorInt(SDL_Surface * dst, Sint16 x1, Sint16 y1, Sint16 x2, Sint16 y2, Uint32 color, int draw_endpoint) +{ + Sint32 xx0, yy0, xx1, yy1; + int result; + Uint32 intshift, erracc, erradj; + Uint32 erracctmp, wgt, wgtcompmask; + int dx, dy, tmp, xdir, y0p1, x0pxdir; + + /* + * Check visibility of clipping rectangle + */ + if ((dst->clip_rect.w==0) || (dst->clip_rect.h==0)) { + return; + } + + /* + * Clip line and test if we have to draw + */ + if (!(clipLine(dst, &x1, &y1, &x2, &y2))) { + return; + } + + /* + * Keep on working with 32bit numbers + */ + xx0 = x1; + yy0 = y1; + xx1 = x2; + yy1 = y2; + + /* + * Reorder points if required + */ + if (yy0 > yy1) { + tmp = yy0; + yy0 = yy1; + yy1 = tmp; + tmp = xx0; + xx0 = xx1; + xx1 = tmp; + } + + /* + * Calculate distance + */ + dx = xx1 - xx0; + dy = yy1 - yy0; + + /* + * Adjust for negative dx and set xdir + */ + if (dx >= 0) { + xdir = 1; + } else { + xdir = -1; + dx = (-dx); + } + + /* + * Check for special cases + */ + if (dx == 0) { + /* + * Vertical line + */ + raster_vline(dst, x1, y1, y2, color); + return; + } else if (dy == 0) { + /* + * Horizontal line + */ + raster_hline(dst, x1, x2, y1, color); + return; + } else if (dx == dy) { + /* + * Diagonal line + */ + raster_line(dst, x1, y1, x2, y2, color); + return; + } + + /* + * Line is not horizontal, vertical or diagonal + */ + result = 0; + + /* + * Zero accumulator + */ + erracc = 0; + + /* + * # of bits by which to shift erracc to get intensity level + */ + intshift = 32 - AAbits; + /* + * Mask used to flip all bits in an intensity weighting + */ + wgtcompmask = AAlevels - 1; + + /* Lock surface */ + if (SDL_MUSTLOCK(dst)) { + if (SDL_LockSurface(dst) < 0) { + return; + } + } + + /* + * Draw the initial pixel in the foreground color + */ + raster_pixelColorNolock(dst, x1, y1, color); + + /* + * x-major or y-major? + */ + if (dy > dx) { + + /* + * y-major. Calculate 16-bit fixed point fractional part of a pixel that + * X advances every time Y advances 1 pixel, truncating the result so that + * we won't overrun the endpoint along the X axis + */ + /* + * Not-so-portable version: erradj = ((Uint64)dx << 32) / (Uint64)dy; + */ + erradj = ((dx << 16) / dy) << 16; + + /* + * draw all pixels other than the first and last + */ + x0pxdir = xx0 + xdir; + while (--dy) { + erracctmp = erracc; + erracc += erradj; + if (erracc <= erracctmp) { + /* + * rollover in error accumulator, x coord advances + */ + xx0 = x0pxdir; + x0pxdir += xdir; + } + yy0++; /* y-major so always advance Y */ + + /* + * the AAbits most significant bits of erracc give us the intensity + * weighting for this pixel, and the complement of the weighting for + * the paired pixel. + */ + wgt = (erracc >> intshift) & 255; + raster_pixelColorWeightNolock (dst, xx0, yy0, color, 255 - wgt); + raster_pixelColorWeightNolock (dst, x0pxdir, yy0, color, wgt); + } + + } 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 so + * that we won't overrun the endpoint along the X axis. + */ + /* + * Not-so-portable version: erradj = ((Uint64)dy << 32) / (Uint64)dx; + */ + erradj = ((dy << 16) / dx) << 16; + + /* + * draw all pixels other than the first and last + */ + y0p1 = yy0 + 1; + while (--dx) { + + erracctmp = erracc; + erracc += erradj; + if (erracc <= erracctmp) { + /* + * Accumulator turned over, advance y + */ + yy0 = y0p1; + y0p1++; + } + xx0 += xdir; /* x-major so always advance X */ + /* + * the AAbits most significant bits of erracc give us the intensity + * weighting for this pixel, and the complement of the weighting for + * the paired pixel. + */ + wgt = (erracc >> intshift) & 255; + raster_pixelColorWeightNolock (dst, xx0, yy0, color, 255 - wgt); + raster_pixelColorWeightNolock (dst, xx0, y0p1, color, wgt); + } + } + + /* + * Do we have to draw the endpoint + */ + if (draw_endpoint) { + /* + * Draw final pixel, always exactly intersected by the line and doesn't + * need to be weighted. + */ + raster_pixelColorNolock (dst, x2, y2, color); + } + + /* Unlock surface */ + if (SDL_MUSTLOCK(dst)) { + SDL_UnlockSurface(dst); + } +} + +void raster_aaline(SDL_Surface *s, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint32_t col) +{ + raster_aalineColorInt(s, x1, y1, x2, y2, col, 1); +} + + + +/* raster :: circle */ + +void raster_circle(SDL_Surface *dst, int16_t x, int16_t y, int16_t r, uint32_t color) +{ + /* sdl-gfx */ + Sint16 left, right, top, bottom; + int result; + Sint16 x1, y1, x2, y2; + Sint16 cx = 0; + Sint16 cy = r; + Sint16 ocx = (Sint16) 0xffff; + Sint16 ocy = (Sint16) 0xffff; + Sint16 df = 1 - r; + Sint16 d_e = 3; + Sint16 d_se = -2 * r + 5; + Sint16 xpcx, xmcx, xpcy, xmcy; + Sint16 ypcy, ymcy, ypcx, ymcx; + + /* + * Check visibility of clipping rectangle + */ + if ((dst->clip_rect.w==0) || (dst->clip_rect.h==0)) { + return; + } + + /* + * Sanity check radius + */ + if (r < 0) { + return; + } + + /* + * Special case for r=0 - draw a point + */ + if (r == 0) { + return (raster_PutPixel(dst, x, y, color)); + } + + /* + * Get circle and clipping boundary and + * test if bounding box of circle is visible + */ + x2 = x + r; + left = dst->clip_rect.x; + if (x2<left) { + return; + } + x1 = x - r; + right = dst->clip_rect.x + dst->clip_rect.w - 1; + if (x1>right) { + return; + } + y2 = y + r; + top = dst->clip_rect.y; + if (y2<top) { + return; + } + y1 = y - r; + bottom = dst->clip_rect.y + dst->clip_rect.h - 1; + if (y1>bottom) { + return; + } + + /* + * Draw + */ + result = 0; + do { + xpcx = x + cx; + xmcx = x - cx; + xpcy = x + cy; + xmcy = x - cy; + if (ocy != cy) { + if (cy > 0) { + ypcy = y + cy; + ymcy = y - cy; + raster_hline(dst, xmcx, xpcx, ypcy, color); + raster_hline(dst, xmcx, xpcx, ymcy, color); +// raster_rect_inline(dst, xmcx, ypcy, 2*cx, 1, color); +// raster_rect_inline(dst, xmcx, ymcy, 2*cx, 1, color); + + } else { + raster_hline(dst, xmcx, xpcx, y, color); +// raster_rect_inline(dst, xmcx, y, 2*cx, 1, color); + } + ocy = cy; + } + if (ocx != cx) { + if (cx != cy) { + if (cx > 0) { + ypcx = y + cx; + ymcx = y - cx; + raster_hline(dst, xmcy, xpcy, ymcx, color); + raster_hline(dst, xmcy, xpcy, ypcx, color); + //raster_rect_inline(dst, xmcy, ymcx, 2*cy, 1, color); + //raster_rect_inline(dst, xmcy, ypcx, 2*cy, 1, color); + } else { + raster_hline(dst, xmcy, xpcy, y, color); + //raster_rect_inline(dst, xmcy, y, 2*cy, 1, color); + } + } + ocx = cx; + } + /* + * Update + */ + if (df < 0) { + df += d_e; + d_e += 2; + d_se += 2; + } else { + df += d_se; + d_e += 2; + d_se += 4; + cy--; + } + cx++; + } while (cx <= cy); +} + + +/* FIXME: convert to fixed pt */ +static void raster_AAFilledEllipse(SDL_Surface *surface, Sint16 xc, Sint16 yc, Sint16 rx, Sint16 ry, Uint32 color) +{ + /* sge */ + /* Sanity check */ + if (rx < 1) + rx = 1; + if (ry < 1) + ry = 1; + + int a2 = rx * rx; + int b2 = ry * ry; + + int ds = 2 * a2; + int dt = 2 * b2; + + int dxt = (int)(a2 / sqrt(a2 + b2)); + + int t = 0; + int s = -2 * a2 * ry; + int d = 0; + + Sint16 x = xc; + Sint16 y = yc - ry; + + Sint16 xs, ys, dyt; + float cp, is, ip, imax = 1.0; + + /* Lock surface */ + if ( SDL_MUSTLOCK(surface) ) + if ( SDL_LockSurface(surface) < 0 ) + return; + + /* "End points" */ + raster_PutPixel(surface, x, y, color); + raster_PutPixel(surface, 2*xc-x, y, color); + + raster_PutPixel(surface, x, 2*yc-y, color); + raster_PutPixel(surface, 2*xc-x, 2*yc-y, color); + + /* unlock surface */ + if (SDL_MUSTLOCK(surface) ) + SDL_UnlockSurface(surface); + + raster_vline(surface, x, y+1, 2*yc-y-1, color); + + int i; + + for (i = 1; i <= dxt; i++) + { + x--; + d += t - b2; + + if (d >= 0) + ys = y - 1; + else if ((d - s - a2) > 0) + { + if ((2 * d - s - a2) >= 0) + ys = y + 1; + else + { + ys = y; + y++; + d -= s + a2; + s += ds; + } + } + else + { + y++; + ys = y + 1; + d -= s + a2; + s += ds; + } + + t -= dt; + + /* Calculate alpha */ + cp = (float) abs(d) / abs(s); + is = cp * imax; + ip = imax - is; + + + /* Lock surface */ + if ( SDL_MUSTLOCK(surface) ) + if ( SDL_LockSurface(surface) < 0 ) + return; + + /* Upper half */ + raster_PutPixelAlpha(surface, x, y, color, (Uint8)(ip*255)); + raster_PutPixelAlpha(surface, 2*xc-x, y, color, (Uint8)(ip*255)); + + raster_PutPixelAlpha(surface, x, ys, color, (Uint8)(is*255)); + raster_PutPixelAlpha(surface, 2*xc-x, ys, color, (Uint8)(is*255)); + + + /* Lower half */ + raster_PutPixelAlpha(surface, x, 2*yc-y, color, (Uint8)(ip*255)); + raster_PutPixelAlpha(surface, 2*xc-x, 2*yc-y, color, (Uint8)(ip*255)); + + raster_PutPixelAlpha(surface, x, 2*yc-ys, color, (Uint8)(is*255)); + raster_PutPixelAlpha(surface, 2*xc-x, 2*yc-ys, color, (Uint8)(is*255)); + + /* unlock surface */ + if (SDL_MUSTLOCK(surface) ) + SDL_UnlockSurface(surface); + + + /* Fill */ + raster_vline(surface, x, y+1, 2*yc-y-1, color); + raster_vline(surface, 2*xc-x, y+1, 2*yc-y-1, color); + raster_vline(surface, x, ys+1, 2*yc-ys-1, color); + raster_vline(surface, 2*xc-x, ys+1, 2*yc-ys-1, color); + } + + dyt = abs(y - yc); + + for (i = 1; i <= dyt; i++) + { + y++; + d -= s + a2; + + if (d <= 0) + xs = x + 1; + else if ((d + t - b2) < 0) + { + if ((2 * d + t - b2) <= 0) + xs = x - 1; + else + { + xs = x; + x--; + d += t - b2; + t -= dt; + } + } + else + { + x--; + xs = x - 1; + d += t - b2; + t -= dt; + } + + s += ds; + + /* Calculate alpha */ + cp = (float) abs(d) / abs(t); + is = cp * imax; + ip = imax - is; + + + /* Lock surface */ + if ( SDL_MUSTLOCK(surface) ) + if ( SDL_LockSurface(surface) < 0 ) + return; + + /* Upper half */ + raster_PutPixelAlpha(surface, x, y, color, (Uint8)(ip*255)); + raster_PutPixelAlpha(surface, 2*xc-x, y, color, (Uint8)(ip*255)); + + raster_PutPixelAlpha(surface, xs, y, color, (Uint8)(is*255)); + raster_PutPixelAlpha(surface, 2*xc-xs, y, color, (Uint8)(is*255)); + + + /* Lower half*/ + raster_PutPixelAlpha(surface, x, 2*yc-y, color, (Uint8)(ip*255)); + raster_PutPixelAlpha(surface, 2*xc-x, 2*yc-y, color, (Uint8)(ip*255)); + + raster_PutPixelAlpha(surface, xs, 2*yc-y, color, (Uint8)(is*255)); + raster_PutPixelAlpha(surface, 2*xc-xs, 2*yc-y, color, (Uint8)(is*255)); + + /* unlock surface */ + if (SDL_MUSTLOCK(surface) ) + SDL_UnlockSurface(surface); + + /* Fill */ + raster_hline(surface, x+1, 2*xc-x-1, y, color); + raster_hline(surface, xs+1, 2*xc-xs-1, y, color); + raster_hline(surface, x+1, 2*xc-x-1, 2*yc-y, color); + raster_hline(surface, xs+1, 2*xc-xs-1, 2*yc-y, color); + } +} + +void raster_aacircle(SDL_Surface *s, int16_t x, int16_t y, int16_t r, uint32_t col) +{ + raster_AAFilledEllipse(s, x, y, r, r, col); +} + +#if 0 +void raster_aacircle(SDL_Surface *s, int16_t x, int16_t y, int16_t r, uint32_t col) +{ + /* sdl-gfx */ + Sint16 left, right, top, bottom; + int result; + Sint16 x1, y1, x2, y2; + Sint16 cx = 0; + Sint16 cy = r; + Sint16 ocx = (Sint16) 0xffff; + Sint16 ocy = (Sint16) 0xffff; + Sint16 df = 1 - r; + Sint16 d_e = 3; + Sint16 d_se = -2 * r + 5; + Sint16 xpcx, xmcx, xpcy, xmcy; + Sint16 ypcy, ymcy, ypcx, ymcx; + + /* + * Check visibility of clipping rectangle + */ + if ((dst->clip_rect.w==0) || (dst->clip_rect.h==0)) { + return; + } + + /* + * Sanity check radius + */ + if (r < 0) { + return; + } + +#if 0 + /* + * Special case for r=0 - draw a point + */ + if (r == 0) { + return (pixelColor(dst, x, y, color)); + } +#endif + + /* + * Get circle and clipping boundary and + * test if bounding box of circle is visible + */ + x2 = x + r; + left = dst->clip_rect.x; + if (x2<left) { + return; + } + x1 = x - r; + right = dst->clip_rect.x + dst->clip_rect.w - 1; + if (x1>right) { + return; + } + y2 = y + r; + top = dst->clip_rect.y; + if (y2<top) { + return; + } + y1 = y - r; + bottom = dst->clip_rect.y + dst->clip_rect.h - 1; + if (y1>bottom) { + return; + } + + /* + * Draw + */ + result = 0; + do { + xpcx = x + cx; + xmcx = x - cx; + xpcy = x + cy; + xmcy = x - cy; + if (ocy != cy) { + if (cy > 0) { + ypcy = y + cy; + ymcy = y - cy; + raster_hlineColor(dst, xmcx, xpcx, ypcy, color); + raster_hlineColor(dst, xmcx, xpcx, ymcy, color); +// raster_rect_inline(dst, xmcx, ypcy, 2*cx, 1, color); +// raster_rect_inline(dst, xmcx, ymcy, 2*cx, 1, color); + + } else { + raster_hlineColor(dst, xmcx, xpcx, y, color); +// raster_rect_inline(dst, xmcx, y, 2*cx, 1, color); + } + ocy = cy; + } + if (ocx != cx) { + if (cx != cy) { + if (cx > 0) { + ypcx = y + cx; + ymcx = y - cx; + raster_hlineColor(dst, xmcy, xpcy, ymcx, color); + raster_hlineColor(dst, xmcy, xpcy, ypcx, color); + //raster_rect_inline(dst, xmcy, ymcx, 2*cy, 1, color); + //raster_rect_inline(dst, xmcy, ypcx, 2*cy, 1, color); + } else { + raster_hlineColor(dst, xmcy, xpcy, y, color); + //raster_rect_inline(dst, xmcy, y, 2*cy, 1, color); + } + } + ocx = cx; + } + /* + * Update + */ + if (df < 0) { + df += d_e; + d_e += 2; + d_se += 2; + } else { + df += d_se; + d_e += 2; + d_se += 4; + cy--; + } + cx++; + } while (cx <= cy); +#if 0 + /* sge */ + Sint16 cx = 0; + Sint16 cy = r; + int draw=1; + Sint16 df = 1 - r; + Sint16 d_e = 3; + Sint16 d_se = -2 * r + 5; + +#ifdef DEBUG + printf("raster_circle %d %d %d\n", x, y, r); +#endif + + if(r < 0) + { + return; + } + + do { + if(draw) + { + raster_rect_inline(s, x-cx, y+cy, 2*cx, 1, col); + raster_rect_inline(s, x-cx, y-cy, 2*cx, 1, col); + draw=0; + } + if(cx!=cy) + { + if(cx) + { + raster_rect_inline(s, x-cy, y-cx, 2*cy, 1, col); + raster_rect_inline(s, x-cy, y+cx, 2*cy, 1, col); + } + else + { + raster_rect_inline(s, x-cy, y, 2*cy, 1, col); + } + } + + if (df < 0) + { + df += d_e; + d_e += 2; + d_se += 2; + } + else + { + df += d_se; + d_e += 2; + d_se += 4; + cy--; + draw=1; + } + cx++; + } while(cx <= cy); +#endif +} +#endif + + + +/* raster :: poly */ + + +/* ---- Filled Polygon */ + +/* Helper qsort callback for polygon drawing */ + +static int gfxPrimitivesCompareInt(const void *a, const void *b) +{ + return (*(const int *) a) - (*(const int *) b); +} + + +/* Global vertex array to use if optional parameters are not given in polygon calls. */ +static int *gfxPrimitivesPolyIntsGlobal = NULL; +static int gfxPrimitivesPolyAllocatedGlobal = 0; + +/* (Note: The last two parameters are optional; but required for multithreaded operation.) */ + +static inline int raster_filledPolygonColorMT(SDL_Surface * dst, const Sint16 * vx, const Sint16 * vy, int n, Uint32 color, int **polyInts, int *polyAllocated) +{ + /* sdl-gfx */ + int result; + int i; + int y, xa, xb; + int miny, maxy; + int x1, y1; + int x2, y2; + int ind1, ind2; + int ints; + int *gfxPrimitivesPolyInts = NULL; + int gfxPrimitivesPolyAllocated = 0; + + /* + * Check visibility of clipping rectangle + */ + if ((dst->clip_rect.w==0) || (dst->clip_rect.h==0)) { + return(0); + } + + /* + * Sanity check number of edges + */ + if (n < 3) { + return -1; + } + + /* + * Map polygon cache + */ + if ((polyInts==NULL) || (polyAllocated==NULL)) { + /* Use global cache */ + gfxPrimitivesPolyInts = gfxPrimitivesPolyIntsGlobal; + gfxPrimitivesPolyAllocated = gfxPrimitivesPolyAllocatedGlobal; + } else { + /* Use local cache */ + gfxPrimitivesPolyInts = *polyInts; + gfxPrimitivesPolyAllocated = *polyAllocated; + } + + /* + * Allocate temp array, only grow array + */ + if (!gfxPrimitivesPolyAllocated) { + gfxPrimitivesPolyInts = (int *) malloc(sizeof(int) * n); + gfxPrimitivesPolyAllocated = n; + } else { + if (gfxPrimitivesPolyAllocated < n) { + gfxPrimitivesPolyInts = (int *) realloc(gfxPrimitivesPolyInts, sizeof(int) * n); + gfxPrimitivesPolyAllocated = n; + } + } + + /* + * Check temp array + */ + if (gfxPrimitivesPolyInts==NULL) { + gfxPrimitivesPolyAllocated = 0; + } + + /* + * Update cache variables + */ + if ((polyInts==NULL) || (polyAllocated==NULL)) { + gfxPrimitivesPolyIntsGlobal = gfxPrimitivesPolyInts; + gfxPrimitivesPolyAllocatedGlobal = gfxPrimitivesPolyAllocated; + } else { + *polyInts = gfxPrimitivesPolyInts; + *polyAllocated = gfxPrimitivesPolyAllocated; + } + + /* + * Check temp array again + */ + if (gfxPrimitivesPolyInts==NULL) { + return(-1); + } + + /* + * Determine Y maxima + */ + miny = vy[0]; + maxy = vy[0]; + for (i = 1; (i < n); i++) { + if (vy[i] < miny) { + miny = vy[i]; + } else if (vy[i] > maxy) { + maxy = vy[i]; + } + } + + /* + * Draw, scanning y + */ + result = 0; + for (y = miny; (y <= maxy); y++) { + ints = 0; + for (i = 0; (i < n); i++) { + if (!i) { + ind1 = n - 1; + ind2 = 0; + } else { + ind1 = i - 1; + ind2 = i; + } + y1 = vy[ind1]; + y2 = vy[ind2]; + if (y1 < y2) { + x1 = vx[ind1]; + x2 = vx[ind2]; + } else if (y1 > y2) { + y2 = vy[ind1]; + y1 = vy[ind2]; + x2 = vx[ind1]; + x1 = vx[ind2]; + } else { + continue; + } + if ( ((y >= y1) && (y < y2)) || ((y == maxy) && (y > y1) && (y <= y2)) ) { + gfxPrimitivesPolyInts[ints++] = ((65536 * (y - y1)) / (y2 - y1)) * (x2 - x1) + (65536 * x1); + } + } + + qsort(gfxPrimitivesPolyInts, ints, sizeof(int), gfxPrimitivesCompareInt); + + for (i = 0; (i < ints); i += 2) { + xa = gfxPrimitivesPolyInts[i] + 1; + xa = (xa >> 16) + ((xa & 32768) >> 15); + xb = gfxPrimitivesPolyInts[i+1] - 1; + xb = (xb >> 16) + ((xb & 32768) >> 15); + raster_hline(dst, xa, xb, y, color); +// raster_rect_inline(dst, xa, y, xb - xa, 1, color); + } + } + + return (result); +} + +void raster_polygon(SDL_Surface *s, int16_t n, int16_t *vx, int16_t *vy, uint32_t col) +{ + raster_filledPolygonColorMT(s, vx, vy, n, col, NULL, NULL); +} + + +void raster_aapolygon(SDL_Surface *dst, int16_t n, int16_t *vx, int16_t *vy, uint32_t color) +{ + /* sdl-gfx + sge w/ rphlx changes: basically, draw aaline border, + then fill. + + the output is not perfect yet but usually looks better than aliasing + */ + int result; + int i; + int y, xa, xb; + int miny, maxy; + int x1, y1; + int x2, y2; + int ind1, ind2; + int ints; + int *gfxPrimitivesPolyInts = NULL; + int gfxPrimitivesPolyAllocated = 0; + const Sint16 *px1, *py1, *px2, *py2; + int **polyInts; + int *polyAllocated; + + polyInts = NULL; + polyAllocated = NULL; + + /* + * Check visibility of clipping rectangle + */ + if ((dst->clip_rect.w==0) || (dst->clip_rect.h==0)) { + return; + } + + /* + * Sanity check number of edges + */ + if (n < 3) { + return; + } + + + /* + * Pointer setup + */ + px1 = px2 = vx; + py1 = py2 = vy; + px2++; + py2++; + + /* + * Draw + */ + result = 0; + for (i = 1; i < n; i++) { + raster_aalineColorInt(dst, *px1, *py1, *px2, *py2, color, 0); + px1 = px2; + py1 = py2; + px2++; + py2++; + } + raster_aalineColorInt(dst, *px1, *py1, *vx, *vy, color, 0); + + /* + * Map polygon cache + */ + if ((polyInts==NULL) || (polyAllocated==NULL)) { + /* Use global cache */ + gfxPrimitivesPolyInts = gfxPrimitivesPolyIntsGlobal; + gfxPrimitivesPolyAllocated = gfxPrimitivesPolyAllocatedGlobal; + } else { + /* Use local cache */ + gfxPrimitivesPolyInts = *polyInts; + gfxPrimitivesPolyAllocated = *polyAllocated; + } + + /* + * Allocate temp array, only grow array + */ + if (!gfxPrimitivesPolyAllocated) { + gfxPrimitivesPolyInts = (int *) malloc(sizeof(int) * n); + gfxPrimitivesPolyAllocated = n; + } else { + if (gfxPrimitivesPolyAllocated < n) { + gfxPrimitivesPolyInts = (int *) realloc(gfxPrimitivesPolyInts, sizeof(int) * n); + gfxPrimitivesPolyAllocated = n; + } + } + + /* + * Check temp array + */ + if (gfxPrimitivesPolyInts==NULL) { + gfxPrimitivesPolyAllocated = 0; + } + + /* + * Update cache variables + */ + if ((polyInts==NULL) || (polyAllocated==NULL)) { + gfxPrimitivesPolyIntsGlobal = gfxPrimitivesPolyInts; + gfxPrimitivesPolyAllocatedGlobal = gfxPrimitivesPolyAllocated; + } else { + *polyInts = gfxPrimitivesPolyInts; + *polyAllocated = gfxPrimitivesPolyAllocated; + } + + /* + * Check temp array again + */ + if (gfxPrimitivesPolyInts==NULL) { + return; + } + + /* + * Determine Y maxima + */ + miny = vy[0]; + maxy = vy[0]; + for (i = 1; (i < n); i++) { + if (vy[i] < miny) { + miny = vy[i]; + } else if (vy[i] > maxy) { + maxy = vy[i]; + } + } + + /* + * Draw, scanning y + */ + result = 0; + for (y = miny; (y <= maxy); y++) { + ints = 0; + for (i = 0; (i < n); i++) { + if (!i) { + ind1 = n - 1; + ind2 = 0; + } else { + ind1 = i - 1; + ind2 = i; + } + y1 = vy[ind1]; + y2 = vy[ind2]; + if (y1 < y2) { + x1 = vx[ind1]; + x2 = vx[ind2]; + } else if (y1 > y2) { + y2 = vy[ind1]; + y1 = vy[ind2]; + x2 = vx[ind1]; + x1 = vx[ind2]; + } else { + continue; + } + if ( ((y >= y1) && (y < y2)) || ((y == maxy) && (y > y1) && (y <= y2)) ) { + gfxPrimitivesPolyInts[ints++] = ((65536 * (y - y1)) / (y2 - y1)) * (x2 - x1) + (65536 * x1); + } + } + + qsort(gfxPrimitivesPolyInts, ints, sizeof(int), gfxPrimitivesCompareInt); + +// o = p = -1; + for (i = 0; (i < ints); i +=2) { +#if 0 + xa = gfxPrimitivesPolyInts[i] + 1; + xa = (xa >> 16) + ((xa & 32768) >> 15); + xb = gfxPrimitivesPolyInts[i+1] - 1; + xb = (xb >> 16) + ((xb & 32768) >> 15); +#else + xa = (gfxPrimitivesPolyInts[i] >> 16); + xb = (gfxPrimitivesPolyInts[i+1] >> 16); +#endif + +#if 0 + if(o < 0) + { + o = xa+1; + } + else if(p < 0) + { + p = xa; + } + + if( (o >= 0) && (p >= 0)) + { + if(p-o < 0) + { + o = p = -1; + continue; + } + + raster_hlineColor(dst, o, p, y, color); + + o = p = -1; + } +#else + + raster_hline(dst, xa+1, xb, y, color); +#endif + +// raster_rect_inline(dst, xa, y, xb - xa, 1, color); + } + } +} + |