685 lines
17 KiB
C++
685 lines
17 KiB
C++
/*
|
|
SDL - Simple DirectMedia Layer
|
|
Copyright (C) 1997-2004 Sam Lantinga
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2 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
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public
|
|
License along with this library; if not, write to the Free
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
Sam Lantinga
|
|
slouken@libsdl.org
|
|
*/
|
|
|
|
|
|
/* This a stretch blit implementation based on ideas given to me by
|
|
Tomasz Cejner - thanks! :)
|
|
|
|
April 27, 2000 - Sam Lantinga
|
|
*/
|
|
|
|
|
|
/* This isn't ready for general consumption yet - it should be folded
|
|
into the general blitting mechanism.
|
|
*/
|
|
|
|
//static unsigned char copy_row[4096];
|
|
|
|
#include "stdafx.h"
|
|
#include <SDL_image.h>
|
|
#include "font.xpm"
|
|
|
|
|
|
#define DEFINE_COPY_ROW(name, type) \
|
|
void name(type *src, int src_w, type *dst, int dst_w) \
|
|
{ \
|
|
int i; \
|
|
int pos, inc; \
|
|
type pixel = 0; \
|
|
\
|
|
pos = 0x10000; \
|
|
inc = (src_w << 16) / dst_w; \
|
|
for ( i=dst_w; i>0; --i ) { \
|
|
while ( pos >= 0x10000L ) { \
|
|
pixel = *src++; \
|
|
pos -= 0x10000L; \
|
|
} \
|
|
*dst++ = pixel; \
|
|
pos += inc; \
|
|
} \
|
|
}
|
|
// the same as above, but pixels ORed with the destination
|
|
#define DEFINE_COPY_ROW_OR(name, type) \
|
|
void name(type *src, int src_w, type *dst, int dst_w) \
|
|
{ \
|
|
int i; \
|
|
int pos, inc; \
|
|
type pixel = 0; \
|
|
\
|
|
pos = 0x10000; \
|
|
inc = (src_w << 16) / dst_w; \
|
|
for ( i=dst_w; i>0; --i ) { \
|
|
while ( pos >= 0x10000L ) { \
|
|
pixel = *src++; \
|
|
pos -= 0x10000L; \
|
|
} \
|
|
*dst++ |= pixel; \
|
|
pos += inc; \
|
|
} \
|
|
}
|
|
|
|
DEFINE_COPY_ROW(copy_row1, Uint8)
|
|
DEFINE_COPY_ROW(copy_row2, Uint16)
|
|
DEFINE_COPY_ROW(copy_row4, Uint32)
|
|
|
|
DEFINE_COPY_ROW_OR(copy_row_or1, Uint8)
|
|
DEFINE_COPY_ROW_OR(copy_row_or2, Uint16)
|
|
DEFINE_COPY_ROW_OR(copy_row_or4, Uint32)
|
|
|
|
/* The ASM code doesn't handle 24-bpp stretch blits */
|
|
void copy_row3(Uint8 *src, int src_w, Uint8 *dst, int dst_w)
|
|
{
|
|
int i;
|
|
int pos, inc;
|
|
Uint8 pixel[3];
|
|
|
|
pos = 0x10000;
|
|
inc = (src_w << 16) / dst_w;
|
|
for ( i=dst_w; i>0; --i ) {
|
|
while ( pos >= 0x10000L ) {
|
|
pixel[0] = *src++;
|
|
pixel[1] = *src++;
|
|
pixel[2] = *src++;
|
|
pos -= 0x10000L;
|
|
}
|
|
*dst++ = pixel[0];
|
|
*dst++ = pixel[1];
|
|
*dst++ = pixel[2];
|
|
pos += inc;
|
|
}
|
|
}
|
|
|
|
/* Perform a stretch blit between two surfaces of the same format.
|
|
NOTE: This function is not safe to call from multiple threads!
|
|
*/
|
|
int SDL_SoftStretchMy(SDL_Surface *src, SDL_Rect *srcrect,
|
|
SDL_Surface *dst, SDL_Rect *dstrect)
|
|
{
|
|
int src_locked;
|
|
int dst_locked;
|
|
int pos, inc;
|
|
int dst_width;
|
|
int dst_maxrow;
|
|
int src_row, dst_row;
|
|
Uint8 *srcp = NULL;
|
|
Uint8 *dstp;
|
|
SDL_Rect full_src;
|
|
SDL_Rect full_dst;
|
|
const int bpp = dst->format->BytesPerPixel;
|
|
|
|
if ( src->format->BitsPerPixel != dst->format->BitsPerPixel ) {
|
|
SDL_SetError("Only works with same format surfaces");
|
|
return(-1);
|
|
}
|
|
|
|
/* Verify the blit rectangles */
|
|
if ( !srcrect ){
|
|
full_src.x = 0;
|
|
full_src.y = 0;
|
|
full_src.w = src->w;
|
|
full_src.h = src->h;
|
|
srcrect = &full_src;
|
|
}
|
|
if ( !dstrect ){
|
|
full_dst.x = 0;
|
|
full_dst.y = 0;
|
|
full_dst.w = dst->w;
|
|
full_dst.h = dst->h;
|
|
dstrect = &full_dst;
|
|
}
|
|
|
|
/* Lock the destination if it's in hardware */
|
|
dst_locked = 0;
|
|
if ( SDL_MUSTLOCK(dst) ) {
|
|
if(SDL_LockSurface(dst) < 0) return -1;
|
|
dst_locked = 1;
|
|
}
|
|
/* Lock the source if it's in hardware */
|
|
src_locked = 0;
|
|
if ( SDL_MUSTLOCK(src) ) {
|
|
if ( SDL_LockSurface(src) < 0 ) {
|
|
if ( dst_locked ) SDL_UnlockSurface(dst);
|
|
// SDL_SetError("Unable to lock source surface");
|
|
return(-1);
|
|
}
|
|
src_locked = 1;
|
|
}
|
|
|
|
/* Set up the data... */
|
|
pos = 0x10000;
|
|
inc = (srcrect->h << 16) / dstrect->h;
|
|
src_row = srcrect->y;
|
|
dst_row = dstrect->y;
|
|
dst_width = dstrect->w*bpp;
|
|
|
|
|
|
/* Perform the stretch blit */
|
|
for ( dst_maxrow = dst_row+dstrect->h; dst_row<dst_maxrow; ++dst_row ) {
|
|
dstp = (Uint8 *)dst->pixels + (dst_row*dst->pitch)
|
|
+ (dstrect->x*bpp);
|
|
while ( pos >= 0x10000L ) {
|
|
srcp = (Uint8 *)src->pixels + (src_row*src->pitch)
|
|
+ (srcrect->x*bpp);
|
|
++src_row;
|
|
pos -= 0x10000L;
|
|
}
|
|
switch (bpp) {
|
|
case 1:
|
|
copy_row1(srcp, srcrect->w, dstp, dstrect->w);
|
|
break;
|
|
case 2:
|
|
copy_row2((Uint16 *)srcp, srcrect->w,
|
|
(Uint16 *)dstp, dstrect->w);
|
|
break;
|
|
case 3:
|
|
copy_row3(srcp, srcrect->w, dstp, dstrect->w);
|
|
break;
|
|
case 4:
|
|
copy_row4((Uint32 *)srcp, srcrect->w,
|
|
(Uint32 *)dstp, dstrect->w);
|
|
break;
|
|
}
|
|
pos += inc;
|
|
}
|
|
|
|
/* We need to unlock the surfaces if they're locked */
|
|
if ( dst_locked ) {
|
|
SDL_UnlockSurface(dst);
|
|
}
|
|
if ( src_locked ) {
|
|
SDL_UnlockSurface(src);
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
// MONO8
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
/* Perform a monochrome stretch blit between two surfaces of the 8bpp format!
|
|
NOTE: This function is not safe to call from multiple threads!
|
|
*/
|
|
void copy8mono(Uint8 *src, int src_w, Uint8 *dst, int dst_w, Uint8 brush)
|
|
{
|
|
int i;
|
|
int pos, inc;
|
|
Uint8 pixel = 0;
|
|
pos = 0x10000;
|
|
inc = (src_w << 16) / dst_w;
|
|
for ( i=dst_w; i>0; --i ) {
|
|
while ( pos >= 0x10000L ) {
|
|
pixel = *src++;
|
|
pos -= 0x10000L;
|
|
}
|
|
//*dst++ = pixel;
|
|
if(pixel) *dst++ = brush;
|
|
else *dst++ = 0;
|
|
pos += inc;
|
|
}
|
|
}
|
|
|
|
int SDL_SoftStretchMono8(SDL_Surface *src, SDL_Rect *srcrect,
|
|
SDL_Surface *dst, SDL_Rect *dstrect, Uint8 brush)
|
|
{//brush - monochrome color (index from palette)
|
|
int src_locked;
|
|
int dst_locked;
|
|
int pos, inc;
|
|
int dst_width;
|
|
int dst_maxrow;
|
|
int src_row, dst_row;
|
|
Uint8 *srcp = NULL;
|
|
Uint8 *dstp;
|
|
SDL_Rect full_src;
|
|
SDL_Rect full_dst;
|
|
const int bpp = dst->format->BytesPerPixel;
|
|
|
|
/* Verify the blit rectangles */
|
|
if ( !srcrect ){
|
|
full_src.x = 0;
|
|
full_src.y = 0;
|
|
full_src.w = src->w;
|
|
full_src.h = src->h;
|
|
srcrect = &full_src;
|
|
}
|
|
if ( !dstrect ){
|
|
full_dst.x = 0;
|
|
full_dst.y = 0;
|
|
full_dst.w = dst->w;
|
|
full_dst.h = dst->h;
|
|
dstrect = &full_dst;
|
|
}
|
|
|
|
/* Lock the destination if it's in hardware */
|
|
dst_locked = 0;
|
|
if ( SDL_MUSTLOCK(dst) ) {
|
|
if(SDL_LockSurface(dst) < 0) return -1;
|
|
dst_locked = 1;
|
|
}
|
|
/* Lock the source if it's in hardware */
|
|
src_locked = 0;
|
|
if ( SDL_MUSTLOCK(src) ) {
|
|
if ( SDL_LockSurface(src) < 0 ) {
|
|
if ( dst_locked ) SDL_UnlockSurface(dst);
|
|
// SDL_SetError("Unable to lock source surface");
|
|
return(-1);
|
|
}
|
|
src_locked = 1;
|
|
}
|
|
|
|
/* Set up the data... */
|
|
pos = 0x10000;
|
|
inc = (srcrect->h << 16) / dstrect->h;
|
|
src_row = srcrect->y;
|
|
dst_row = dstrect->y;
|
|
dst_width = dstrect->w*bpp;
|
|
|
|
|
|
/* Perform the stretch blit */
|
|
for ( dst_maxrow = dst_row+dstrect->h; dst_row<dst_maxrow; ++dst_row ) {
|
|
dstp = (Uint8 *)dst->pixels + (dst_row*dst->pitch)
|
|
+ (dstrect->x*bpp);
|
|
while ( pos >= 0x10000L ) {
|
|
srcp = (Uint8 *)src->pixels + (src_row*src->pitch)
|
|
+ (srcrect->x*bpp);
|
|
++src_row;
|
|
pos -= 0x10000L;
|
|
}
|
|
switch (bpp) {
|
|
case 1:
|
|
copy8mono(srcp, srcrect->w, dstp, dstrect->w, brush);
|
|
break;
|
|
default: break;
|
|
/* case 2:
|
|
copy_row2((Uint16 *)srcp, srcrect->w,
|
|
(Uint16 *)dstp, dstrect->w);
|
|
break;
|
|
case 3:
|
|
copy_row3(srcp, srcrect->w, dstp, dstrect->w);
|
|
break;
|
|
case 4:
|
|
copy_row4((Uint32 *)srcp, srcrect->w,
|
|
(Uint32 *)dstp, dstrect->w);
|
|
break;*/
|
|
}
|
|
pos += inc;
|
|
}
|
|
|
|
/* We need to unlock the surfaces if they're locked */
|
|
if ( dst_locked ) {
|
|
SDL_UnlockSurface(dst);
|
|
}
|
|
if ( src_locked ) {
|
|
SDL_UnlockSurface(src);
|
|
}
|
|
return(0);
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
/* SDL_SoftStretchOr - the same as SDL_SoftStretch, but ORed with destination
|
|
NOTE: 24bpp does not support -- beom beotiger 2007 November
|
|
*/
|
|
|
|
/* Perform a stretch blit between two surfaces of the same format.
|
|
NOTE: This function is not safe to call from multiple threads!
|
|
*/
|
|
int SDL_SoftStretchOr(SDL_Surface *src, SDL_Rect *srcrect,
|
|
SDL_Surface *dst, SDL_Rect *dstrect)
|
|
{
|
|
int src_locked;
|
|
int dst_locked;
|
|
int pos, inc;
|
|
int dst_width;
|
|
int dst_maxrow;
|
|
int src_row, dst_row;
|
|
Uint8 *srcp = NULL;
|
|
Uint8 *dstp;
|
|
SDL_Rect full_src;
|
|
SDL_Rect full_dst;
|
|
const int bpp = dst->format->BytesPerPixel;
|
|
|
|
if ( src->format->BitsPerPixel != dst->format->BitsPerPixel ) {
|
|
SDL_SetError("Only works with same format surfaces");
|
|
return(-1);
|
|
}
|
|
|
|
/* Verify the blit rectangles */
|
|
if ( !srcrect ){
|
|
full_src.x = 0;
|
|
full_src.y = 0;
|
|
full_src.w = src->w;
|
|
full_src.h = src->h;
|
|
srcrect = &full_src;
|
|
}
|
|
if ( !dstrect ){
|
|
full_dst.x = 0;
|
|
full_dst.y = 0;
|
|
full_dst.w = dst->w;
|
|
full_dst.h = dst->h;
|
|
dstrect = &full_dst;
|
|
}
|
|
|
|
/* Lock the destination if it's in hardware */
|
|
dst_locked = 0;
|
|
if ( SDL_MUSTLOCK(dst) ) {
|
|
if(SDL_LockSurface(dst) < 0) return -1;
|
|
dst_locked = 1;
|
|
}
|
|
/* Lock the source if it's in hardware */
|
|
src_locked = 0;
|
|
if ( SDL_MUSTLOCK(src) ) {
|
|
if ( SDL_LockSurface(src) < 0 ) {
|
|
if ( dst_locked ) SDL_UnlockSurface(dst);
|
|
// SDL_SetError("Unable to lock source surface");
|
|
return(-1);
|
|
}
|
|
src_locked = 1;
|
|
}
|
|
|
|
/* Set up the data... */
|
|
pos = 0x10000;
|
|
inc = (srcrect->h << 16) / dstrect->h;
|
|
src_row = srcrect->y;
|
|
dst_row = dstrect->y;
|
|
dst_width = dstrect->w*bpp;
|
|
|
|
|
|
/* Perform the stretch blit */
|
|
for ( dst_maxrow = dst_row+dstrect->h; dst_row<dst_maxrow; ++dst_row ) {
|
|
dstp = (Uint8 *)dst->pixels + (dst_row*dst->pitch)
|
|
+ (dstrect->x*bpp);
|
|
while ( pos >= 0x10000L ) {
|
|
srcp = (Uint8 *)src->pixels + (src_row*src->pitch)
|
|
+ (srcrect->x*bpp);
|
|
++src_row;
|
|
pos -= 0x10000L;
|
|
}
|
|
switch (bpp) {
|
|
case 1:
|
|
copy_row_or1(srcp, srcrect->w, dstp, dstrect->w);
|
|
break;
|
|
case 2:
|
|
copy_row_or2((Uint16 *)srcp, srcrect->w,
|
|
(Uint16 *)dstp, dstrect->w);
|
|
break;
|
|
case 3:
|
|
copy_row3(srcp, srcrect->w, dstp, dstrect->w);
|
|
break;
|
|
case 4:
|
|
copy_row_or4((Uint32 *)srcp, srcrect->w,
|
|
(Uint32 *)dstp, dstrect->w);
|
|
break;
|
|
}
|
|
pos += inc;
|
|
}
|
|
|
|
/* We need to unlock the surfaces if they're locked */
|
|
if ( dst_locked ) {
|
|
SDL_UnlockSurface(dst);
|
|
}
|
|
if ( src_locked ) {
|
|
SDL_UnlockSurface(src);
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------*/
|
|
/* ---------------------- FONT routines ---------------------------*/
|
|
/* ----------------------------------------------------------------*/
|
|
|
|
SDL_Surface *font_sfc = NULL; // used for font
|
|
|
|
// defined in .h file
|
|
//#define FONT_SIZE_X 6
|
|
//#define FONT_SIZE_Y 8
|
|
// chars in row in font bitmap
|
|
//#define CHARS_IN_ROW 45
|
|
|
|
bool fonts_initialization(void)
|
|
{
|
|
|
|
SDL_Surface *temp_surface;
|
|
temp_surface = IMG_ReadXPMFromArray (font_xpm);
|
|
font_sfc = SDL_DisplayFormat(temp_surface);
|
|
|
|
SDL_FreeSurface(temp_surface);
|
|
/* Transparant color is BLACK: */
|
|
SDL_SetColorKey(font_sfc,SDL_SRCCOLORKEY,SDL_MapRGB(font_sfc->format,0,0,0));
|
|
|
|
return true;
|
|
}/* fonts_initialization */
|
|
|
|
|
|
void fonts_termination(void)
|
|
{
|
|
SDL_FreeSurface(font_sfc);
|
|
font_sfc = NULL;
|
|
} /* fonts_termination */
|
|
|
|
|
|
void font_print(int x,int y,const char *text,SDL_Surface *surface, double kx, double ky)
|
|
{// kx, ky - stretching koefficients for width and height of destination chars respectively
|
|
int i, c;
|
|
SDL_Rect s,d;
|
|
|
|
|
|
for(i = 0; text[i] != 0 && x < surface->w; i++) {
|
|
int row;
|
|
c = int(text[i]);
|
|
|
|
if(c > 127 || c < 0) c = '?'; // cut-off non-ASCII chars
|
|
|
|
row = c / CHARS_IN_ROW;
|
|
|
|
s.x = (c - (row * CHARS_IN_ROW)) * (FONT_SIZE_X + 1) + 1;
|
|
s.y = (row) * (FONT_SIZE_Y + 1) + 1;
|
|
s.h = FONT_SIZE_Y;
|
|
s.w = FONT_SIZE_X;
|
|
|
|
d.x = x + i * FONT_SIZE_X * kx;
|
|
d.y = y;
|
|
d.w = s.w * kx;
|
|
d.h = s.h * ky;
|
|
SDL_SoftStretchOr(font_sfc, &s, surface, &d);
|
|
} /* for */
|
|
} /* font_print */
|
|
|
|
|
|
void font_print_right(int x,int y,const char *text,SDL_Surface *surface, double kx, double ky)
|
|
{// kx, ky - stretching koefficients for width and height of destination chars respectively
|
|
int i, c;
|
|
SDL_Rect s,d;
|
|
|
|
x -= strlen(text) * FONT_SIZE_X * kx;
|
|
|
|
for(i=0;text[i]!=0 && x<surface->w;i++) {
|
|
int row;
|
|
c = int(text[i]);
|
|
if(c > 127 || c < 0) c = '?'; // cut-off non-ASCII chars
|
|
|
|
row = c / CHARS_IN_ROW;
|
|
s.x = (c - (row * CHARS_IN_ROW)) * (FONT_SIZE_X + 1) + 1;
|
|
s.y = (row) * (FONT_SIZE_Y + 1) + 1;
|
|
s.h = FONT_SIZE_Y;
|
|
s.w = FONT_SIZE_X;
|
|
|
|
d.x = x + i * FONT_SIZE_X * kx;
|
|
d.y = y;
|
|
d.w = s.w * kx;
|
|
d.h = s.h * ky;
|
|
SDL_SoftStretchOr(font_sfc, &s, surface, &d);
|
|
} /* for */
|
|
} /* font_print_right */
|
|
|
|
|
|
void font_print_centered(int x, int y, const char *text, SDL_Surface *surface, double kx, double ky)
|
|
{// kx, ky - stretching koefficients for width and height of destination chars respectively
|
|
int i, c;
|
|
SDL_Rect s,d;
|
|
|
|
x -= strlen(text) * FONT_SIZE_X * kx / 2; // centered position
|
|
if(x < 0) x = 0;
|
|
|
|
for(i=0; text[i] != 0 && ((x * kx) < surface->w); i++) {
|
|
int row;
|
|
c = int(text[i]);
|
|
if(c > 127 || c < 0) c = '?'; // cut-off non-ASCII chars
|
|
|
|
row = c / CHARS_IN_ROW;
|
|
s.x = (c - (row * CHARS_IN_ROW)) * (FONT_SIZE_X + 1) + 1;
|
|
s.y = (row) * (FONT_SIZE_Y + 1) + 1;
|
|
s.h = FONT_SIZE_Y;
|
|
s.w = FONT_SIZE_X;
|
|
|
|
d.x = x + i * FONT_SIZE_X * kx;
|
|
d.y = y;
|
|
d.w = s.w * kx;
|
|
d.h = s.h * ky;
|
|
SDL_SoftStretchOr(font_sfc, &s, surface, &d);
|
|
} /* for */
|
|
} /* font_print_centered */
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
////// Some auxiliary functions //////////////
|
|
///////////////////////////////////////////////////////////////////////////
|
|
void surface_fader(SDL_Surface *surface,float r_factor,float g_factor,float b_factor,float a_factor,SDL_Rect *r)
|
|
{
|
|
|
|
// my rebiuld for 8BPP palettized surfaces! --bb
|
|
|
|
SDL_Rect r2;
|
|
int i/*,x,y,offs*/;
|
|
// Uint8 rtable[256],gtable[256],btable[256],atable[256];
|
|
SDL_Color mycolors[256]; // faded colors
|
|
SDL_Color *colors;
|
|
// SDL_Surface *tmp;
|
|
|
|
if (r==0) {
|
|
r2.x=0;
|
|
r2.y=0;
|
|
r2.w=surface->w;
|
|
r2.h=surface->h;
|
|
r=&r2;
|
|
} /* if */
|
|
|
|
// fading just for 8BPP surfaces!
|
|
if (surface->format->BytesPerPixel != 1) return;
|
|
|
|
colors = (SDL_Color *) surface->format->palette->colors; // get pointer to origin colors
|
|
for(i=0;i<256;i++) {
|
|
mycolors[i].r=(Uint8)(colors[i].r * r_factor);
|
|
mycolors[i].g=(Uint8)(colors[i].g * g_factor);
|
|
mycolors[i].b=(Uint8)(colors[i].b * b_factor);
|
|
} /* for */
|
|
|
|
SDL_SetColors(surface, mycolors, 0 ,256);
|
|
|
|
// if ((surface->flags&SDL_HWSURFACE)!=0) {
|
|
// /* HARDWARE SURFACE!!!: */
|
|
// tmp=SDL_CreateRGBSurface(SDL_SWSURFACE,surface->w,surface->h,32,0,0,0,0);
|
|
// SDL_BlitSurface(surface,0,tmp,0);
|
|
// SDL_LockSurface(tmp);
|
|
// pixels = (Uint8 *)(tmp->pixels);
|
|
// } else {
|
|
// SDL_LockSurface(surface);
|
|
// pixels = (Uint8 *)(surface->pixels);
|
|
// } /* if */
|
|
//
|
|
// for(y=r->y;y<r->y+r->h && y<surface->h;y++) {
|
|
// for(x=r->x,offs=y*surface->pitch+r->x*4;x<r->x+r->w && x<surface->w;x++,offs+=4) {
|
|
// pixels[offs+ROFFSET]=rtable[pixels[offs+ROFFSET]];
|
|
// pixels[offs+GOFFSET]=gtable[pixels[offs+GOFFSET]];
|
|
// pixels[offs+BOFFSET]=btable[pixels[offs+BOFFSET]];
|
|
// pixels[offs+AOFFSET]=atable[pixels[offs+AOFFSET]];
|
|
// } /* for */
|
|
// } /* for */
|
|
//
|
|
// if ((surface->flags&SDL_HWSURFACE)!=0) {
|
|
// /* HARDWARE SURFACE!!!: */
|
|
// SDL_UnlockSurface(tmp);
|
|
// SDL_BlitSurface(tmp,0,surface,0);
|
|
// SDL_FreeSurface(tmp);
|
|
// } else {
|
|
// SDL_UnlockSurface(surface);
|
|
// } /* if */
|
|
|
|
|
|
} /* surface_fader */
|
|
|
|
void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
|
|
{
|
|
SDL_Rect clip;
|
|
int bpp = surface->format->BytesPerPixel;
|
|
|
|
SDL_GetClipRect(surface,&clip);
|
|
|
|
if (x<clip.x || x>=clip.x+clip.w ||
|
|
y<clip.y || y>=clip.y+clip.h) return;
|
|
|
|
if (x<0 || x>=surface->w ||
|
|
y<0 || y>=surface->h) return;
|
|
|
|
Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
|
|
|
|
switch(bpp) {
|
|
case 1:
|
|
*p = pixel;
|
|
break;
|
|
|
|
case 2:
|
|
*(Uint16 *)p = pixel;
|
|
break;
|
|
|
|
case 3:
|
|
if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
|
|
p[0] = (pixel >> 16) & 0xff;
|
|
p[1] = (pixel >> 8) & 0xff;
|
|
p[2] = pixel & 0xff;
|
|
} else {
|
|
p[0] = pixel & 0xff;
|
|
p[1] = (pixel >> 8) & 0xff;
|
|
p[2] = (pixel >> 16) & 0xff;
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
*(Uint32 *)p = pixel;
|
|
break;
|
|
}
|
|
} /* putpixel */
|
|
|
|
|
|
void rectangle(SDL_Surface *surface, int x, int y, int w, int h, Uint32 pixel)
|
|
{
|
|
int i;
|
|
|
|
for(i=0;i<w;i++) {
|
|
putpixel(surface,x+i,y,pixel);
|
|
putpixel(surface,x+i,y+h,pixel);
|
|
} /* for */
|
|
for(i=0;i<=h;i++) {
|
|
putpixel(surface,x,y+i,pixel);
|
|
putpixel(surface,x+w,y+i,pixel);
|
|
} /* for */
|
|
} /* rectangle */
|
|
|