basegfx.h

Go to the documentation of this file.

/*
    This file is part of Advanced Strategic Command; http://www.asc-hq.de
    Copyright (C) 1994-1999  Martin Bickel  and  Marc Schellenberger

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; see the file COPYING. If not, write to the 
    Free Software Foundation, Inc., 59 Temple Place, Suite 330, 
    Boston, MA  02111-1307  USA
*/

#ifndef basegfxH
#define basegfxH

#include "libs/sdlmm/src/sdlmm.h"
#include "global.h"
#include "palette.h"
#include "sdl/graphics.h"
#include "graphics/surface.h"

#pragma pack(1)

const int colorDepth = 4;



struct  tgraphmodeparameters {
            int           resolutionx      ;       
            int           resolutiony      ;       
            int           actsetpage       ;       
            int           windowstatus     ;       
            int           granularity      ;       
            int           scanlinelength   ;       
            int           scanlinenumber   ;       
            int           bytesperscanline ;       
            int           activegraphmode  ;       
            int           videomemory      ;       
            int           byteperpix       ;       
            PointerSizedInt linearaddress    ;       
            int           pagetoset        ;       
            char          redmasksize       ;      
            char          redfieldposition  ;      
            char          greenmasksize     ;      
            char          greenfieldposition;      
            char          bluemasksize      ;      
            char          bluefieldposition ;      
            char          bitperpix         ;      
            char          memorymodel;             
            int           directscreenaccess;      
            Surface*      surface;
            tgraphmodeparameters() : surface(NULL) {};
    };


struct trleheader {
   Uint16 id;
   Uint16 size;
   char rle;
   Uint16 x;
   Uint16 y;
};

const int black = 0;
const int    blue        = 1;
const int    green       = 2;
const int    cyan        = 3;
const int    red         = 4;
const int    magenta     = 5 ;
const int    brown       = 6  ;
const int    lightgray   = 7   ;
const int    darkgray    = 8    ;
const int    lightblue   = 9     ;
const int    lightgreen  = 42  ; // 10      
const int    lightcyan   = 119 ; // 11      
const int    lightred    = 52  ; // 12        
const int    lightmagenta = 5  ; // 13         
const int    yellow       = 103;  // 14          
const int    white        = 160;  // 15           

extern tgraphmodeparameters   *agmp;
extern tgraphmodeparameters   *hgmp;

extern dacpalette256* activepalette256;


extern tgraphmodeparameters activegraphmodeparameters;
extern tgraphmodeparameters hardwaregraphmodeparameters;

extern dacpalette256 activepalette;
// extern int       palette16[256][4];
extern void*     xlatbuffer;



 extern void bar(int x1, int y1, int x2, int y2, char color);

 extern void getimage(int x1, int y1, int x2, int y2, void *buffer);

 extern void putimage(int x1, int y1, void *buffer);

 extern void putxlatfilter ( int x1, int y1, void* pictbuffer, char* xlattables );

 extern void putspriteimage(int x1, int y1, void *buffer);

 extern void putrotspriteimage(int x1, int y1, void *buffer, int rotationvalue);

 extern void putrotspriteimage90(int x1, int y1, void *buffer, int rotationvalue);

 extern void putrotspriteimage180(int x1, int y1, void *buffer, int rotationvalue);

 extern void putrotspriteimage270(int x1, int y1, void *buffer, int rotationvalue);

 extern void puttexture ( int x1, int y1, int x2, int y2, void *texture );

 extern void putspritetexture ( int x1, int y1, int x2, int y2, void *texture );

 extern void putimageprt ( int x1, int y1, int x2, int y2, void *texture, int dx, int dy );

#if 0

 extern void* xlatpict ( ppixelxlattable xl, void* pntr );
#endif

 extern int loga2 ( int a );
 

 extern SPoint getPixelRotationLocation( SPoint pos, int width, int height, int degrees );


 extern void putpixel(int x1, int y1, int color);
 
 extern int getpixel(int x1, int y1);

 extern int imagesize(int x1, int y1, int x2, int y2);
 
 extern void getpicsize(void* p, int& width, int& height);

 extern int  getpicsize2(void* p );

 extern void* uncompress_rlepict ( void* pict );

 extern void  generategrayxlattable( ppixelxlattable tab, char offset, char size, dacpalette256* pal );

#if 0

 extern void putshadow ( int x1, int y1, void* ptr, ppixelxlattable xl  );
#endif


extern void         rahmen( bool invers, int x1, int y1, int x2, int y2);

extern void         line(int x1, int y1, int x2, int y2, char color );

extern void xorline( int x1, int y1, int x2, int y2, char color );

extern void rectangle(int x1, int y1, int x2, int y2, char color );

extern void  xorrectangle(int x1, int y1, int x2, int y2, char color) ;

void putinterlacedrotimage ( int x1, int y1, void* ptr, int rotation );

void rotatepict90 ( void* s, void* d );

void flippict ( void* s, void* d, int dir = 1 );

void* halfpict ( void* vbuf );


char* rotatepict ( void* image, int angle );


char* rotatepict_grw ( void* image, int organgle );


extern int getpixelfromimage ( void* buf, int x, int y );

extern void ellipse ( int x1, int y1, int x2, int y2, int color, float tolerance );

extern void putmask ( int x1, int y1, void* vbuf, int newtransparence );

extern void putpicturemix ( int x1, int y1, void* ptr, int rotation, char* mixbuf );


extern void copySurface2screen( void );
extern void copySurface2screen( int x1, int y1, int x2, int y2 );



class tdrawline {
         public: 
           void start ( int x1, int y1, int x2, int y2 );
           virtual void putpix ( int x, int y ) = 0;
           virtual ~tdrawline() {};
       };

class tvirtualdisplay {
           Surface* surface;
           void* buf;
           tgraphmodeparameters oldparams;
           void init ( int x, int y, int col, int depth );
        public: 
           tvirtualdisplay ( int x, int y );
           tvirtualdisplay ( int x, int y, int color, int depth= 8 );
           Surface& getSurface();
           ~tvirtualdisplay ();
        };



/**************************************************************
The following routines were an early attempt at rewriting the graphic engine. 
It was never continued and the routines are hardly used at all.
They can be completely scrapped should the graphic engine be rewritten 
sometime...
***************************************************************/

struct trgbpixel {
       public:
         union {
            int rgb;
            #if SDL_BYTEORDER == SDL_LIL_ENDIAN
            struct { char r,g,b,a;  }channel;
            #else
            struct { char a,b,g,r;  }channel;
            #endif
          };
       //    mix ( const trgbpixel* pix );
          bool isTransparent();
        };

#define alphabase 64

#if SDL_BYTEORDER == SDL_LIL_ENDIAN
#define TCalpha 0xfefefe
#else
#define TCalpha 0xfefefe
#endif

class TrueColorImage {
         int xsize;
         int ysize;
         trgbpixel* pix;
      public:
         TrueColorImage ( int x, int y );
         trgbpixel getpix ( int x, int y );
         trgbpixel* getpix ( void );
         void setpix ( int x, int y, int r, int g, int b, int alpha = 0 );
         void setpix ( int x, int y, const trgbpixel& pix );
         int getxsize( void );
         int getysize( void );

         ~TrueColorImage();

   };

extern TrueColorImage* zoomimage ( void* buf, int xsize, int ysize, dacpalette256 pal, int interpolate = 1, int proportional = 1 );

extern char* convertimage ( TrueColorImage* img, dacpalette256 pal );

extern TrueColorImage* convertimage2tc ( void* buf, dacpalette256 pal );

// extern char truecolor2pal_table[262144];

extern void putimage ( int x1, int y1, TrueColorImage* tci );
extern void putimage_noalpha ( int x1, int y1, TrueColorImage* tci );

TrueColorImage* smoothimage ( TrueColorImage* src );


extern TrueColorImage* getimage(int x1, int y1, int x2, int y2 );


class fatalgraphicserror { 
        char st[1000];
      public:
        fatalgraphicserror ( const char* strng );
        fatalgraphicserror ( void );
      };

class collategraphicoperations {
         int olddirectscreenaccess;
         int x1, y1, x2, y2;
         int status;
       public:
         collategraphicoperations ( void );
         collategraphicoperations ( int _x1, int _y1, int _x2, int _y2 );
         ~collategraphicoperations ();
         void on ( void );
         void off ( void );
};



#pragma pack()

extern int fullscreen;

extern void setWindowCaption ( const char* s );

#ifdef use_truecolor2pal

extern void* convertSurface ( SDLmm::Surface& s, bool paletteTranslation = true );
#endif

extern SPoint getPixelRotationLocation( SPoint pos, int width, int height, int degrees );

#endif

---