RotateImage.cpp

Go to the documentation of this file.

#define __VCS_CPP__


#ifdef _WIN32_WCE
#       define ROTATE_KEYS
#       define ROTATE_NUMPAD
#       define ROTATION CLOCKWISE
#else
#       define ROTATION OFF
#endif

#include "RotateImage.h"
#include <stdlib.h>

#include <SDL/begin_code.h>


#define RotateY_CCW(z, x,y)   (((z)->h)-(x)-1)
#define RotateY_CW(z,x,y)     (x)
#define RotateY_NULL(s, x, y) (y)

#define RotateX_CCW(z, x, y)  (y)
#define RotateX_CW(z,x,y)     (((z)->w)-(y)-1)
#define RotateX_NULL(z, x, y) (x)

#define RotateW_R(w,h)        (h)
#define RotateW_F(w,h)        (w)

#define RotateH_R(w,h)        (w)
#define RotateH_F(w,h)        (h)

#define UnRotateW             RotateW
#define UnRotateH             RotateH

#define RotateWH(v) { int w,h; w=(v)->w; h=(v)->h; (v)->w=RotateW(w,h); (v)->h=RotateH(w,h); }


VCS_Surface *__VideoSurface=NULL;

static int VCS_TransCoord_C(Sint16 *x, Sint16 *y)
{
  Sint16 tx;
  VCS_Surface *Ref=VCS_GetVideoSurface();
  if((x==NULL)||(y==NULL)||(Ref==NULL)) return(-1);

  tx=(*x);
  (*x)=Ref->OldSurface->w-(*y);
  (*y)=tx;
  
  return(0);                          
}

static SDL_Rect *VCS_TransRect_C(const VCS_Surface *Ref, const SDL_Rect *Rect, SDL_Rect *NewRect)
{
        if((Ref==NULL)||(Rect==NULL)||(NewRect==NULL)) return NULL;

        SDL_Rect Out={0};
        
        Out.w=Rect->h;
        Out.h=Rect->w;
        Out.y=Rect->x;
        Out.x=Ref->OldSurface->w-(Rect->y+Rect->h);

        memcpy(NewRect,&Out,sizeof(SDL_Rect));
        return(NewRect);
}

static int VCS_TransCoord_CC(Sint16 *x, Sint16 *y)
{
  Sint16 ty;
  VCS_Surface *Ref=VCS_GetVideoSurface();
  if((x==NULL)||(y==NULL)||(Ref==NULL)) return(-1);

  ty=(*y);
  (*y)=Ref->OldSurface->h-(*x);
  (*x)=ty;
  return(0);  
}

static  SDL_Rect *VCS_TransRect_CC(const VCS_Surface *Ref, const SDL_Rect *Rect, SDL_Rect *NewRect)
{       
        if((Ref==NULL)||(Rect==NULL)||(NewRect==NULL)) return NULL;

        SDL_Rect Out={0};

        Out.w=Rect->h;
        Out.h=Rect->w;
        Out.x=Rect->y;
        Out.y=Ref->OldSurface->h-(Rect->x+Rect->w);

        memcpy(NewRect,&Out,sizeof(SDL_Rect));
        return NewRect;
}

int VCS_TransCoord_NULL(Sint16 *x, Sint16 *y)
{
  if((x==NULL)||(y==NULL))  return(-1);
  else                      return(0);
}

static  SDL_Rect *VCS_TransRect_NULL(const VCS_Surface *Ref, const SDL_Rect *Rect, SDL_Rect *NewRect)
{
        if((Ref==NULL)||(Rect==NULL)||(NewRect==NULL)) return NULL;

        memcpy(NewRect,Rect,sizeof(SDL_Rect));
        return NewRect;
}


#if( ROTATION == CLOCKWISE)

#define VCS_TransRect     VCS_TransRect_C
#define VCS_UnTransRect   VCS_TransRect_CC
#define VCS_TransCoord    VCS_TransCoord_C
#define VCS_UnTransCoord  VCS_TransCoord_CC

#define RotateW RotateW_R
#define RotateH RotateH_R

#define RotateX RotateX_CW
#define RotateY RotateY_CW
#define UnRotateX RotateX_CCW
#define UnRotateY RotateY_CCW


SDLKey VCLK_LEFT        = SDLK_DOWN;
SDLKey VCLK_RIGHT       = SDLK_UP;
SDLKey VCLK_UP          = SDLK_RIGHT;
SDLKey VCLK_DOWN        = SDLK_LEFT;
SDLKey VCLK_KP9         = SDLK_KP7;
SDLKey VCLK_KP8         = SDLK_KP4;
SDLKey VCLK_KP7         = SDLK_KP1;
SDLKey VCLK_KP6         = SDLK_KP8;
SDLKey VCLK_KP5         = SDLK_KP5;     //Not really needed, just there for continuity
SDLKey VCLK_KP4         = SDLK_KP2;
SDLKey VCLK_KP3         = SDLK_KP9;
SDLKey VCLK_KP2         = SDLK_KP6;
SDLKey VCLK_KP1         = SDLK_KP3;
#elif ( ROTATION == CCLOCKWISE ) 

#define VCS_TransRect     VCS_TransRect_CC
#define VCS_UnTransRect   VCS_TransRect_C
#define VCS_TransCoord    VCS_TransCoord_CC
#define VCS_UnTransCoord  VCS_TransCoord_C


#define RotateW RotateW_R
#define RotateH RotateH_R

#define RotateX RotateX_CCW
#define RotateY RotateY_CCW
#define UnRotateX RotateX_CW
#define UnRotateY RotateY_CW

SDLKey VCLK_KP9         = SDLK_KP3;
SDLKey VCLK_KP8         = SDLK_KP6;
SDLKey VCLK_KP7         = SDLK_KP9;
SDLKey VCLK_KP6         = SDLK_KP2;
SDLKey VCLK_KP5         = SDLK_KP5;     //Not really needed, just there for continuity
SDLKey VCLK_KP4         = SDLK_KP4;
SDLKey VCLK_KP3         = SDLK_KP1;
SDLKey VCLK_KP2         = SDLK_KP8;
SDLKey VCLK_KP1         = SDLK_KP7;
SDLKey VCLK_LEFT        = SDLK_UP;
SDLKey VCLK_RIGHT       = SDLK_DOWN;
SDLKey VCLK_UP          = SDLK_RIGHT;
SDLKey VCLK_DOWN        = SDLK_LEFT;
#elif (ROTATION==NONE)

#define VCS_TransRect     VCS_TransRect_NULL
#define VCS_UnTransRect   VCS_TransRect_NULL
#define VCS_TransCoord    VCS_TransCoord_NULL
#define VCS_UnTransCoord  VCS_TransCoord_NULL

#define RotateW RotateW_F
#define RotateH RotateH_F

#define RotateX RotateX_NULL
#define RotateY RotateY_NULL
#define UnRotateX RotateX_NULL
#define UnRotateY RotateY_NULL


SDLKey VCLK_KP9         = SDLK_KP9;
SDLKey VCLK_KP8         = SDLK_KP8;
SDLKey VCLK_KP7         = SDLK_KP8;


SDLKey VCLK_KP6         = SDLK_KP6;
SDLKey VCLK_KP5         = SDLK_KP5;     //Not really needed, just there for continuity
SDLKey VCLK_KP4         = SDLK_KP4;
SDLKey VCLK_KP3         = SDLK_KP3;
SDLKey VCLK_KP2         = SDLK_KP2;
SDLKey VCLK_KP1         = SDLK_KP1;
SDLKey VCLK_LEFT        = SDLK_LEFT;
SDLKey VCLK_RIGHT       = SDLK_RIGHT;
SDLKey VCLK_UP          = SDLK_UP;
SDLKey VCLK_DOWN        = SDLK_DOWN;
#else
#error "No default rotation selected."
#endif

int VCS_TranslateCoords(Sint16 *x, Sint16 *y)
{
  return(VCS_TransCoord(x,y));
}

VCS_Surface *SDL_VCS(SDL_Surface *surface)
{
        if(surface==NULL) return NULL;
        VCS_Surface *es=new VCS_Surface();
        memset(es,0,sizeof(VCS_Surface));
        memcpy(es,surface,sizeof(SDL_Surface));
        es->OldSurface=surface;

        RotateWH(es);
        es->RotationMode=ROTATION;

        return es;
}

/*
int VCS_TransCoords(Sint16 *x, Sint16 *y)
{
  SDL_Rect r={0,0,0,0};
  if((x==NULL)||(y==NULL))  return(-1);      
  r.x=*x;
  r.y=*y;
  
  VCS_TranslateRect(VCS_GetVideoSurface,&r,&r);
  (*x)=r.x;
  (*y)=r.y;
  
  return(0);  
}*/

void VCS_WM_SetIcon(VCS_Surface *icon, Uint8 *mask)
{
        SDL_WM_SetIcon(icon->OldSurface,mask);
}

void VCS_ReinitSurface(VCS_Surface *surfOut, SDL_Surface *surfIn)
{
  surfOut->OldSurface=surfIn;
  memcpy(surfOut,surfIn,sizeof(SDL_Surface));

  RotateWH(surfOut);
  surfOut->RotationMode=ROTATION;
}

int VCS_SetColors(VCS_Surface *surface, SDL_Color *colors, int firstcolor, int ncolors)
{
        int retVal=SDL_SetColors(surface->OldSurface,colors,firstcolor,ncolors);

        surface->format=surface->OldSurface->format;
        return retVal;
}

void VCS_UnlockSurface(VCS_Surface *surface)
{
        if(surface==NULL) return;       
        
        //Don't attempt to unlock non-locked surfaces
        if(surface->VCS_Locked>0)
        {
                //Decrement the lock-count
                surface->VCS_Locked--;

                //If it's 0, unlock it.

                if(surface->VCS_Locked==0)
                {
                        //Get the virtual surface they've been screwing with
                        SDL_Surface *surf=surface->LockedSurface;

                        //They're not gonna use it anymore.
                        surface->LockedSurface=NULL;
                
                        //Unlock it so we can blit it
                        SDL_UnlockSurface(surf);

                        //Rotate it - return it to physical coordinates
                        SDL_Surface *newSurf=VCS_RotateSurface(surf,true);


                        //Copy it over our real surface
                        SDL_BlitSurface(newSurf,NULL,surface->OldSurface,NULL);

                        //Free the new surface
                        SDL_FreeSurface(newSurf);

                        //Make the virtual surface look real again
                        memcpy(surface,surface->OldSurface,sizeof(SDL_Surface));

                        int w=surface->OldSurface->w;
                        int h=surface->OldSurface->h;
                        
                        //Restore virtual height and witdh
                        surface->h=RotateH(w,h);
                        surface->w=RotateW(w,h);
                }
        }
}

int VCS_LockSurface(VCS_Surface *surface)
{
        if(surface==NULL) return -1;
        
        //If this is the first lock:
        if(surface->VCS_Locked==0)
        {
                //Take the rotated image, and create an unrotated copy. 
                SDL_Surface *surf=VCS_UnRotateSurface(surface,false);

                //If can't be locked, free it and return error.
                if(SDL_LockSurface(surf)==-1)
                {
                        SDL_FreeSurface(surf);
                        return -1;
                }
                
                surface->LockedSurface=surf;
                memcpy(surface,surf,sizeof(SDL_Surface));               
        }

        surface->VCS_Locked++;

        return(0);
}


int FindColor(VCS_Surface *surface, SDL_Color *color)
{       
    if(surface->OldSurface->format->BitsPerPixel!=8)
        {
                fprintf(stderr,"FindColor> Surface not 8bpp\n");
                return -1;
        }

        for(int i=0; i<surface->OldSurface->format->palette->ncolors; i++)
        if(memcmp(surface->OldSurface->format->palette->colors+i,color,sizeof(SDL_Color))==0)
        {
                //Color found
                return i;
        }

        //color not found
        return -1;
}

VCS_Surface *VCS_DisplayFormat(VCS_Surface *surface)
{
  SDL_Surface *newsurf=SDL_DisplayFormat(surface->OldSurface);

  if(newsurf==NULL) return(NULL);
  else              return(SDL_VCS(newsurf));
}

void VCS_SetColorKey(VCS_Surface *surface, Uint32 flag, Uint32 color)
{
        SDL_SetColorKey(surface->OldSurface,flag,color);
  surface->flags=surface->OldSurface->flags;  
}

 void VCS_GetClipRect(VCS_Surface *surface, SDL_Rect *rect)
{
        if(rect==NULL) return;

        SDL_GetClipRect(surface->OldSurface,rect);

        VCS_UnTransRect(surface,rect,rect);
}

 void VCS_SetClipRect(VCS_Surface *surface, SDL_Rect *rect)
{
        SDL_Rect rectOut;
        if(VCS_TransRect(surface,rect,&rectOut)==NULL)
        {
                SDL_SetClipRect(surface->OldSurface,NULL);
        }
        else
        {
                SDL_SetClipRect(surface->OldSurface,&rectOut);

        }
}

void VCS_TranslateEvent(SDL_Event *event)
{
        if(event==NULL) return;

        int x=0,y=0,xrel=0,yrel=0;

        SDL_Surface *surf=SDL_GetVideoSurface();
        if(surf==NULL) return;

        VCS_Surface *surface=SDL_VCS(surf);

        switch (event->type)
        {
#ifdef ROTATE_KEYS
        case SDL_KEYDOWN:
        case SDL_KEYUP:

                switch(event->key.keysym.sym)
                {
                case SDLK_UP:
                        event->key.keysym.sym=VCLK_UP;
                        break;
                case SDLK_DOWN:


                        event->key.keysym.sym=VCLK_DOWN;
                        break;


                case SDLK_LEFT:
                        event->key.keysym.sym=VCLK_LEFT;
                        break;
                case SDLK_RIGHT:
                        event->key.keysym.sym=VCLK_RIGHT;
                        break;

#ifdef ROTATE_NUMPAD
                case SDLK_KP1:
                        event->key.keysym.sym=VCLK_KP1;
                        break;
                case SDLK_KP2:
                        event->key.keysym.sym=VCLK_KP2;
                        break;
                case SDLK_KP3:
                        event->key.keysym.sym=VCLK_KP3;
                        break;
                case SDLK_KP4:
                        event->key.keysym.sym=VCLK_KP4;
                        break;
                case SDLK_KP5:
                        event->key.keysym.sym=VCLK_KP5;
                        break;
                case SDLK_KP6:
                        event->key.keysym.sym=VCLK_KP6;
                        break;
                case SDLK_KP7:
                        event->key.keysym.sym=VCLK_KP7;
                        break;
                case SDLK_KP8:
                        event->key.keysym.sym=VCLK_KP8;
                        break;
                case SDLK_KP9:
                        event->key.keysym.sym=VCLK_KP9;
                        break;

                default:
                        break;
#endif
                }
                break;
#endif
        case SDL_MOUSEMOTION:           
                x=event->motion.x;
                y=event->motion.y;
                xrel=event->motion.xrel;
                yrel=event->motion.yrel;

                event->motion.x=UnRotateX(surface,x,y);

                event->motion.y=UnRotateY(surface,x,y);

                switch(ROTATION)
                {
                case OFF:
                        break;
                case CLOCKWISE:
                        event->motion.yrel=-xrel;
                        event->motion.xrel=yrel;
                        break;
                case CCLOCKWISE:
                        event->motion.yrel=xrel;
                        event->motion.xrel=-yrel;
                        break;

                default:
                        break;
                }

                break;

        case SDL_MOUSEBUTTONDOWN:
        case SDL_MOUSEBUTTONUP:

                x=event->button.x;
                y=event->button.y;
                event->button.x=UnRotateX(surface,x,y);
                event->button.y=UnRotateY(surface,x,y);

                break;

        default:
                break;
        }
}


int VCS_PollEvent(SDL_Event *event)
{
        static SDL_Event oldEvent;

        int retval=SDL_PollEvent(&oldEvent);

        memcpy(event,&oldEvent,sizeof(SDL_Event));
        
        VCS_TranslateEvent(event);

        return(retval);
}

int VCS_PeepEvents(SDL_Event *events, int numevents, SDL_eventaction action, Uint32 mask)
{
        int n;

        int retval=SDL_PeepEvents(events,numevents,action,mask);

        for(n=0; n<retval; n++)
        {
                VCS_TranslateEvent(events+n);
        }

        return retval;
}


VCS_Surface *VCS_GetVideoSurface()
{

  return(__VideoSurface);
}


int VCS_SetAlpha(VCS_Surface *surface, Uint32 flag, Uint8 alpha)
{
        return(SDL_SetAlpha(surface->OldSurface,flag,alpha));
}

Uint8 VCS_GetMouseState(int *x, int *y)
{
        VCS_Surface *vid;
        int x2,y2;
        int retval;

        vid=VCS_GetVideoSurface();
        if(vid==NULL) return 0;

        retval=SDL_GetMouseState(&x2,&y2);

        if(x!=NULL)
        {
                (*x)=UnRotateX(vid,x2,y2);
        }

        if(y!=NULL)
        {
                (*y)=UnRotateY(vid,x2,y2);
        }
        return retval;
}


void VCS_FreeSurface(VCS_Surface *surface)
{

        SDL_FreeSurface(surface->OldSurface);

        delete surface;
}

 int VCS_Flip(VCS_Surface *surface)
{
        return(SDL_Flip(surface->OldSurface));
}

void PrintRect(SDL_Rect *rect)
{
        if(rect)        fprintf(stderr,"PrintRect> xy:(%d,%d) wh:(%d,%d)\n",rect->x,rect->y,rect->w,rect->h);
        else            fprintf(stderr,"PrintRect> NULL rect\n");
}

 void PrintSurface(SDL_Surface *s)
{
        if(!s)  fprintf(stderr,"PrintSurface> Blank surface.\n");
        else
        {
                SDL_PixelFormat *f=s->format;
                fprintf(stderr,"<PrintSurface> wh:(%d,%d) P:%u PixelData:%p\n",s->w,s->h,s->pitch,s->pixels);
                fprintf(stderr,"Flag:%d BPP: %d\n",s->flags,f->BitsPerPixel);
                fprintf(stderr,"RM:%08x GM:%08x BM:%08x AM: %08x\n",f->Rmask,f->Gmask,f->Bmask,f->Amask);
                PrintRect(&s->clip_rect);
                fprintf(stderr,"</PrintSurface>\n");
        }
}

 VCS_Surface *VCS_ConvertSurface(VCS_Surface *ref,SDL_PixelFormat *format, Uint32 flags)
{
        SDL_Surface *oldSurface=ref->OldSurface;
        return(SDL_VCS(SDL_ConvertSurface(oldSurface,format,flags)));
} 


VCS_Surface *VCS_CreateRGBSurface(Uint32 flags,Sint16 w,Sint16 h,Uint8 bpp,Uint32 rmask, Uint32 gmask, Uint32 bmask, Uint32 amask)
{       
        SDL_Surface *s=SDL_CreateRGBSurface(flags,RotateW(w,h),RotateH(w,h),bpp,rmask,gmask,bmask,amask);

        return(SDL_VCS(s));
}

void VCS_FillRect(VCS_Surface *surface, SDL_Rect *rect, Uint32 color)
{
        if(!surface) return;

        SDL_Rect dstrect;
        SDL_Rect *outrect=VCS_TransRect(surface,rect,&dstrect);

        SDL_FillRect(surface->OldSurface,outrect,color);
}

VCS_Surface *VCS_SetVideoMode(Sint32 w, Sint32 h, Uint8 bpp,Uint32 flags)
{       
        SDL_Surface *s=SDL_SetVideoMode(RotateW(w,h),RotateH(w,h),bpp,flags);

  if(s==NULL)
    return(NULL);
        else if(__VideoSurface==NULL)
    __VideoSurface=SDL_VCS(s);
        else
                VCS_ReinitSurface(__VideoSurface,s);
        
        return(__VideoSurface);
}

void VCS_Quit(void)
{
        if(__VideoSurface!=NULL)
        {
                delete __VideoSurface;
        }

        SDL_Quit();
}

int VCS_BlitSurface(VCS_Surface *source, SDL_Rect *srcrect, VCS_Surface *dest, SDL_Rect *dstrect)
{
        if((!source)||(!dest)) return -1;

        SDL_Rect src_rect={0};
        SDL_Rect dst_rect={0};

        memset(&src_rect,0,sizeof(SDL_Rect));
        memset(&dst_rect,0,sizeof(SDL_Rect));

        if(srcrect==NULL)
        {
                src_rect.x=0;
                src_rect.y=0;
                src_rect.w=source->w;
                src_rect.h=source->h;           
        }
        else
        {
                src_rect=*srcrect;
        }

        if(dstrect==NULL)
        {
                dst_rect.x=0;
                dst_rect.y=0;
        }
        else
        {
                dst_rect=*dstrect;
        }

  dst_rect.w=src_rect.w;
  dst_rect.h=src_rect.h;
  


        VCS_TransRect(source,&src_rect,&src_rect);


        VCS_TransRect(dest,&dst_rect,&dst_rect);


        return(SDL_BlitSurface(source->OldSurface,&src_rect,dest->OldSurface,&dst_rect));
}

void VCS_UpdateRect(VCS_Surface *screen,Sint32 x, Sint32 y, Sint32 w, Sint32 h)
{
        if(!screen) return;
        SDL_Rect rect={x,y,w,h};

        if((x==0)&&(y==0)&&(w==0)&&(h==0))
        {
                SDL_Flip(screen->OldSurface);
                return;
        }

        VCS_UpdateRects(screen,1,&rect);
}

 void VCS_UpdateRects(VCS_Surface *screen, int numrects, SDL_Rect *rects)
{
        if(!screen) return;
        if(!rects) return;

        SDL_Rect *newrects=new SDL_Rect[numrects];
        for(int n=0; n<numrects; n++)
        {               VCS_TransRect(screen,&(rects[n]),&(newrects[n]));
        }

        SDL_UpdateRects(screen->OldSurface,numrects,newrects);

        delete[](newrects);
}

//Create an empty surface with the same format as a pre-existing one.
SDL_Surface *CloneSurface(SDL_Surface *surface, Uint32 w, Uint32 h)
{
        if(surface==NULL) return NULL;


        SDL_PixelFormat *format=surface->format;

        SDL_Surface *out=SDL_CreateRGBSurface(  SDL_SWSURFACE,w,h,
                                                                        format->BitsPerPixel,
                                                                        format->Rmask, format->Gmask,
                                                                        format->Bmask, format->Amask    );

        SDL_Surface *out2=SDL_ConvertSurface(out,format,SDL_SWSURFACE);
        SDL_FreeSurface(out);
        return(out2);
}

VCS_Surface *VCS_CloneSurface(VCS_Surface *surface, Uint32 w, Uint32 h)
{
        if(surface==NULL) return NULL;

        SDL_PixelFormat *format=surface->format;

        VCS_Surface *out=VCS_CreateRGBSurface(  SDL_SWSURFACE,w,h,
                                                                        format->BitsPerPixel,
                                                                        format->Rmask, format->Gmask,
                                                                        format->Bmask, format->Amask    );

        VCS_Surface *out2=VCS_ConvertSurface(out,format,SDL_SWSURFACE);
        VCS_FreeSurface(out);
        return(out2);
}


//Take a surface, rotate it to specs, and return it.
//Note, that the actual w and h may be reversed compared
//to the virtual ones.
//Expects an actual SDL_Surface, not one 'tampered' with by
//VCS.  Internal use only.
SDL_Surface *VCS_UnRotateSurface(VCS_Surface *surface, bool autofree)
{       
        if(surface==NULL) return NULL;

        int x, y;
        SDL_Surface *rSurf=surface->OldSurface;
        SDL_Surface *buffer;

        buffer=CloneSurface(rSurf,UnRotateW(rSurf->w,rSurf->h),UnRotateH(rSurf->w,rSurf->h));

        if(buffer==NULL) return NULL;

        SDL_LockSurface(buffer);
        SDL_LockSurface(rSurf);

        for(y=0; y<rSurf->h; y++)
        for(x=0; x<rSurf->w; x++)
        {
                Uint32 d=getpixel(rSurf,x,y);           
                putpixel(buffer,UnRotateX(buffer,x,y),UnRotateY(buffer,x,y),d);
        }


        SDL_UnlockSurface(rSurf);
        SDL_UnlockSurface(buffer);

        if(autofree)
        {
                VCS_FreeSurface(surface);
        }

        return(buffer);
}




//Take a surface, rotate it to specs, and return it.
//Note, that the actual w and h may be reversed compared
//to the virtual ones.
//Expects an actual SDL_Surface, not one 'tampered' with by
//VCS.  Internal use only.
SDL_Surface *VCS_RotateSurface(SDL_Surface *surface, bool autofree)
{
        SDL_Surface *buffer;
        Sint32 x,y;     

        buffer=CloneSurface(surface,RotateW(surface->w,surface->h),RotateH(surface->w,surface->h));     

        if(buffer==NULL)
        {
                if(autofree)
                {
                        SDL_FreeSurface(surface);
                }
                return NULL;
        }

        SDL_LockSurface(surface);
        SDL_LockSurface(buffer);
                
                for(y=0; y<surface->h; y++)
                for(x=0; x<surface->w; x++)
                {
                        Uint32 d=getpixel(surface,x,y);         
                        putpixel(buffer,RotateX(buffer,x,y),RotateY(buffer,x,y),d);
                }               

        SDL_UnlockSurface(buffer);
        SDL_UnlockSurface(surface);

        if(autofree)
        {
                SDL_FreeSurface(surface);
        }

        return(buffer);
}


void VCS_SaveBMP(VCS_Surface *surface, const char *file)
{
        SDL_SaveBMP(surface->OldSurface,file);
}

VCS_Surface *VCS_Load(const char *file)
{
  SDL_Surface *Surface=IMG_Load(file);
        if(Surface!=NULL)
        {
                Surface=VCS_RotateSurface(Surface);
                return(SDL_VCS(Surface));
        }
        else
        {
                return NULL;
        }  
}

//Load a bmp surface into a RotSurface pointer.
VCS_Surface *VCS_LoadBMP(const char *file)
{
        SDL_Surface *Surface=SDL_LoadBMP(file);
        if(Surface!=NULL)
        {
                Surface=VCS_RotateSurface(Surface);
                return(SDL_VCS(Surface));

        }
        else
        {
                return NULL;
        }       
}

Uint32 getpixel(SDL_Surface *surface, int x, int y)
{
    int bpp = surface->format->BytesPerPixel;
    /* Here p is the address to the pixel we want to retrieve */
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

    switch(bpp) {
    case 1:
        return *p;

    case 2:

        return *(Uint16 *)p;

    case 3:
        if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
            return p[0] << 16 | p[1] << 8 | p[2];
        else
            return p[0] | p[1] << 8 | p[2] << 16;

    case 4:
        return *(Uint32 *)p;

    default:
        return 0;       /* shouldn't happen, but avoids warnings */
    }
}

//Gee, I dunno...
 void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
{
    int bpp = surface->format->BytesPerPixel;
    /* Here p is the address to the pixel we want to set */


    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;
        default:
        break;       /* shouldn't happen, but avoids warnings */

    }
}

#include <SDL/close_code.h>

---