TakeV/dxx-rebirth
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
dxx-rebirth/include/gr.h
zicodxx d64c3d1023 change byte to sbyte
2006-10-06 14:41:31 +00:00

783 lines
27 KiB
C
Executable file
Raw Blame History

/*
THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
SOFTWARE CORPORATION ("PARALLAX"). PARALLAX, IN DISTRIBUTING THE CODE TO
END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
IN USING, DISPLAYING, AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
FREE PURPOSES. IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES. THE END-USER UNDERSTANDS
AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION. ALL RIGHTS RESERVED.
*/
/*
* $Source: /cvsroot/dxx-rebirth/d1x-rebirth/include/gr.h,v $
* $Revision: 1.1.1.1 $
* $Author: zicodxx $
* $Date: 2006/03/17 19:46:08 $
*
* Definitions for graphics lib.
*
* $Log: gr.h,v $
* Revision 1.1.1.1 2006/03/17 19:46:08 zicodxx
* initial import
*
* Revision 1.14 2000/10/28 09:31:08 donut
* OGL support for fullscreen toggle key while in menus
*
* Revision 1.13 1999/12/15 06:07:20 donut
* added font->ft_aw field (average width) since ft_w is usually too large on proportional fonts
*
* Revision 1.12 1999/11/21 13:00:09 donut
* Changed screen_mode format. Now directly encodes res into a 32bit int, rather than using arbitrary values.
*
* Revision 1.11 1999/11/20 10:05:16 donut
* variable size menu patch from Jan Bobrowski. Variable menu font size support and a bunch of fixes for menus that didn't work quite right, by me (MPM).
*
* Revision 1.10 1999/10/14 04:48:21 donut
* alpha fixes, and gl_font args
*
* Revision 1.9 1999/10/08 08:50:55 donut
* fixed ogl sub bitmap support
*
* Revision 1.8 1999/10/07 21:15:58 donut
* ogl updates (new gltexture struct, and new font handling)
*
* Revision 1.7 1999/09/30 23:02:27 donut
* opengl direct support for ingame and normal menus, fonts as textures, and automap support
*
* Revision 1.6 1999/09/24 05:47:01 donut
* added sizing (and padding) of ogl textures up to next multiple of 2, so they don't get mangled
*
* Revision 1.5 1999/09/24 03:37:29 donut
* preliminary GLX fullscreen support
*
* Revision 1.4 1999/09/21 04:05:55 donut
* mostly complete OGL implementation (still needs bitmap handling (reticle), and door/fan textures are corrupt)
*
* Revision 1.3 1999/09/16 03:34:15 donut
* cleaned up fullscreen toggle code to make it easy to add support to other targets later, and added -nosdlvidmodecheck
*
* Revision 1.2 1999/08/05 22:53:41 sekmu
*
* D3D patch(es) from ADB
*
* Revision 1.1.1.1 1999/06/14 22:02:13 donut
* Import of d1x 1.37 source.
*
* Revision 1.7 1995/09/13 08:39:44 allender
* added prototype for gr_bitblt_cockpit
*
* Revision 1.6 1995/08/23 18:47:01 allender
* fixed compiler warnings on mcc
*
* Revision 1.5 1995/08/14 15:51:01 allender
* added #define for transparency color
*
* Revision 1.4 1995/06/13 13:03:55 allender
* added graphics mode
*
* Revision 1.3 1995/04/18 09:50:16 allender
* *** empty log message ***
*
* Revision 1.2 1995/04/07 07:32:33 allender
* *** empty log message ***
*
* Revision 1.1 1995/03/09 09:04:16 allender
* Initial revision
*
*
* --- PC RCS information ---
* Revision 1.45 1994/11/18 22:50:21 john
* Changed shorts to ints in parameters.
*
* Revision 1.44 1994/11/13 13:04:07 john
* Added paged out bit in bitmap structure. Commented out the
* poly code that is never used.
*
* Revision 1.43 1994/11/09 23:04:56 mike
* Add avg_color field.
*
* Revision 1.42 1994/10/27 00:53:35 john
* Added RLE Flag to bitmap structere.
*
* Revision 1.41 1994/10/26 23:55:52 john
* Took out roller; Took out inverse table.
*
* Revision 1.40 1994/08/11 17:59:12 mike
* Assembler merge functions written for 3 rotations of bitmaps.
*
* Revision 1.39 1994/08/10 12:24:56 matt
* Added support for colors fonts & kerned fonts
* Made our own font file format
*
* Revision 1.38 1994/07/27 18:30:18 john
* Took away the blending table.
*
* Revision 1.37 1994/06/16 15:25:06 mike
* Add flag BM_FLAG_NO_LIGHTING.
*
* Revision 1.36 1994/05/31 10:01:22 john
* *** empty log message ***
*
* Revision 1.35 1994/05/31 07:53:34 john
* *** empty log message ***
*
* Revision 1.34 1994/05/14 17:19:41 matt
* Added externs
*
* Revision 1.33 1994/05/12 17:33:09 john
* Added circle code.
*
* Revision 1.32 1994/05/06 12:50:16 john
* Added supertransparency; neatend things up; took out warnings.
*
* Revision 1.31 1994/05/04 10:06:06 john
* Added flag for bitmap super-transparency.
*
* Revision 1.30 1994/05/03 19:38:56 john
* *** empty log message ***
*
* Revision 1.29 1994/04/22 11:16:05 john
* *** empty log message ***
*
* Revision 1.28 1994/04/08 16:59:32 john
* Add fading poly's; Made palette fade 32 instead of 16.
*
* Revision 1.27 1994/03/16 17:29:52 john
* *** empty log message ***
*
* Revision 1.26 1994/03/16 17:20:51 john
* Added slow palette searching options.
*
* Revision 1.25 1994/03/14 17:59:20 john
* Added function to check bitmap's transparency.
*
* Revision 1.24 1994/03/14 16:56:26 john
* Changed grs_bitmap structure to include bm_flags.
*
* Revision 1.23 1994/02/18 15:32:30 john
* *** empty log message ***
*
* Revision 1.22 1994/01/25 11:40:48 john
* Added gr_check_mode function.
*
* Revision 1.21 1994/01/12 13:45:24 john
* Added scaler.
*
* Revision 1.20 1993/12/21 19:58:24 john
* added selector stuff
*
* Revision 1.19 1993/12/21 11:40:40 john
* *** empty log message ***
*
* Revision 1.18 1993/12/09 15:02:08 john
* Changed palette stuff majorly
*
* Revision 1.17 1993/12/07 12:32:05 john
* moved bmd_palette to gr_palette
*
* Revision 1.16 1993/11/28 12:08:06 mike
* Change prototype for rotate_bitmap.
*
* Revision 1.15 1993/11/18 14:22:51 mike
* Add prototype for rotate_bitmap.
*
* Revision 1.14 1993/11/17 19:00:59 mike
* Add prototype for test_rotate_bitmap
*
* Revision 1.13 1993/11/16 11:28:58 john
* *** empty log message ***
*
* Revision 1.12 1993/10/26 13:17:43 john
* *** empty log message ***
*
* Revision 1.11 1993/10/15 16:23:37 john
* y
*
* Revision 1.10 1993/09/28 15:32:33 john
* added def for save/restore vidmode
*
* Revision 1.9 1993/09/28 12:51:46 matt
* Added aspect ratio to grs_screen structure
*
* Revision 1.8 1993/09/26 22:45:12 matt
* Changed prototypes for line functions to take fixes, not ints.
*
* Revision 1.7 1993/09/26 18:58:16 john
* fadein/out stuff
*
* Revision 1.6 1993/09/14 16:26:44 matt
* Changed gr_change_mode() to be gr_set_mode()
*
* Revision 1.4 1993/09/14 13:08:45 john
* added gr_change_mode
*
* Revision 1.3 1993/09/08 13:56:03 matt
* Put 'if' block around body of file; added bitmap type BM_RGB15
*
* Revision 1.2 1993/09/08 13:02:14 john
* Changed structure definitions a bit.
*
* Revision 1.1 1993/09/08 11:25:15 john
* Initial revision
*
*
*/
#ifndef _GR_H
#define _GR_H
// ZICO - for FONTSCALE_X/Y
#include "args.h"
#include "cfile.h"
#include "types.h"
#include "fix.h"
#ifdef __MSDOS__
// selector is used to avoid keeping a base pointer around in the texture mapper
#define BITMAP_SELECTOR
#endif
// #define SWAP_0_255 0 // swap black and white
#define TRANSPARENCY_COLOR 255 // palette entry of transparency color -- 255 on the PC
#define GR_FADE_LEVELS 34
#define GR_ACTUAL_FADE_LEVELS 32
extern int Gr_scanline_darkening_level;
typedef struct _grs_point {
fix x,y;
} grs_point;
extern int fixedfont;
extern int hiresfont;
// ZICO - we use this defines to scale the fon bitmaps itself, spacing between letters and rows
#ifdef OGL
#define FONTSCALE_X(x) ((fixedfont)?x:(x)*((SWIDTH/ ((hiresfont&&SWIDTH>=640&&SHEIGHT>=480)?640:320))))
#define FONTSCALE_Y(x) ((fixedfont)?x:(x)*((SHEIGHT/((hiresfont&&SWIDTH>=640&&SHEIGHT>=480)?480:200))))
#else // without OGL we don't scale. But instead of defining out eery single FONTSCALE_* call we just do not scale
#define FONTSCALE_X(x) (x)
#define FONTSCALE_Y(x) (x)
#endif
//old font structure, could not add new items to it without screwing up gr_init_font
typedef struct _grs_font {
int16_t ft_w,ft_h; // Width and height in pixels
int16_t ft_flags; // Proportional?
int16_t ft_baseline; //
ubyte ft_minchar, // The first and last chars defined by
ft_maxchar; // This font
int16_t ft_bytewidth; // Width in unsigned chars
u_int32_t ft_data; // Ptr to raw data.
u_int32_t ft_chars; // Ptrs to data for each char (required for prop font)
u_int32_t ft_widths; // Array of widths (required for prop font)
u_int32_t ft_kerndata; // Array of kerning triplet data
}
old_grs_font;
#define BM_LINEAR 0
#define BM_FLAG_TRANSPARENT 1
#define BM_FLAG_SUPER_TRANSPARENT 2
#define BM_FLAG_NO_LIGHTING 4
#define BM_FLAG_RLE 8 // A run-length encoded bitmap.
#define BM_FLAG_PAGED_OUT 16 // This bitmap's data is paged out.
#define BM_FLAG_INITIALIZED 32
#ifdef D1XD3D
#define BM_MAGIC_NUMBER 0x13579bdf
//changed BM_D3D constants to prevent system crash if accidentally accessed
//(it would be nice if Win9x actually protected first pages...)
//#define BM_D3D_RENDER 1
//#define BM_D3D_DISPLAY 2
#define BM_D3D_RENDER 0xf0000001
#define BM_D3D_DISPLAY 0xf0000002
#endif
typedef struct _grs_bitmap {
short bm_x,bm_y; // Offset from parent's origin
short bm_w,bm_h; // width,height
sbyte bm_type; // 0=Linear, 1=ModeX, 2=SVGA
sbyte bm_flags; // bit 0 on means it has transparency.
// bit 1 on means it has supertransparency
// bit 2 on means it doesn't get passed through lighting.
short bm_rowsize; // unsigned char offset to next row
unsigned char *bm_data; // ptr to pixel data...
// Linear = *parent+(rowsize*y+x)
// ModeX = *parent+(rowsize*y+x/4)
// SVGA = *parent+(rowsize*y+x)
#ifdef BITMAP_SELECTOR
unsigned short bm_selector;
#endif
ubyte avg_color; // Average color of all pixels in texture map.
sbyte unused; // to 4-byte align.
#ifdef D1XD3D
void *pvSurface;
int iMagic;
#endif
#ifdef OGL
struct _ogl_texture *gltexture;
struct _grs_bitmap *bm_parent;
#endif
} grs_bitmap;
//new font structure, which does not suffer from the inability to add new items
typedef struct _new_grs_font {
short ft_w,ft_h; // Width and height in pixels
float ft_aw; // "Average" width (on proportional fonts, ft_w is usually much larger than normal)
short ft_flags; // Proportional?
short ft_baseline; //
ubyte ft_minchar, // The first and last chars defined by
ft_maxchar; // This font
short ft_bytewidth; // Width in unsigned chars
ubyte * ft_data; // Ptr to raw data.
ubyte ** ft_chars; // Ptrs to data for each char (required for prop font)
short * ft_widths; // Array of widths (required for prop font)
ubyte * ft_kerndata; // Array of kerning triplet data
old_grs_font *oldfont;
#ifdef OGL
grs_bitmap * ft_bitmaps;
grs_bitmap ft_parent_bitmap;
#endif
} grs_font;
typedef struct _grs_canvas {
grs_bitmap cv_bitmap; // the bitmap for this canvas
short cv_color; // current color
short cv_drawmode; // fill,XOR,etc.
grs_font * cv_font; // the currently selected font
short cv_font_fg_color; // current font foreground color (-1==Invisible)
short cv_font_bg_color; // current font background color (-1==Invisible)
} grs_canvas;
typedef struct _grs_screen { // This is a video screen
grs_canvas sc_canvas; // Represents the entire screen
u_int32_t sc_mode; // Video mode number
short sc_w, sc_h; // Actual Width and Height
fix sc_aspect; //aspect ratio (w/h) for this screen
} grs_screen;
// Num Cols Rows Bpp Mode Pages Aspect
// --- ---- ---- --- ---- ----- ------
// 0 320 200 8 C 1.0 1.2:1
// 1 320 200 8 U 4.0 1.2
// 2 320 240 8 U 3.4 1.0
// 3 360 200 8 U 3.6 1.4
// 4 360 240 8 U 3.0 1.1
// 5 376 282 8 U 2.5 1.0
// 6 320 400 8 U 2.0 0.6
// 7 320 480 8 U 1.7 0.5
// 8 360 400 8 U 1.8 0.7
// 9 360 480 8 U 1.5 0.6
// 10 360 360 8 U 2.0 0.8
// 11 376 308 8 U 2.3 0.9
// 12 376 564 8 U 1.2 0.5
// 13 640 400 8 V 4.1 1.2 (Assuming 1 Meg video RAM)
// 14 640 480 8 V 3.4 1.0
// 15 800 600 8 V 2.2 1.0
// 16 1024 768 8 V 1.0 1.0
// 17 640 480 15 V 1.0 1.0
// 18 800 600 15 V 1.0 1.0
//new more versatile res setting method. added 11/21/99 Matt Mueller.
#define SM(w,h) ((((u_int32_t)w)<<16)+(((u_int32_t)h)&0xFFFF))
#define SM_W(m) (m>>16)
#define SM_H(m) (m&0xFFFF)
#define SM_ORIGINAL 0
/*#define SM_ORIGINAL -1
#define SM_320x200C 0
#define SM_320x200U 1
#define SM_320x240U 2
#define SM_360x200U 3
#define SM_360x240U 4
#define SM_376x282U 5
#define SM_320x400U 6
#define SM_320x480U 7
#define SM_360x400U 8
#define SM_360x480U 9
#define SM_360x360U 10
#define SM_376x308U 11
#define SM_376x564U 12
#define SM_640x400V 13
#define SM_640x480V 14
#define SM_800x600V 15
#define SM_1024x768V 16
#define SM_640x480V15 17
#define SM_800x600V15 18
#define SM_320x200x8 1
#define SM_320x200x8UL 2
#define SM_320x200x16 3*/
#define BM_LINEAR 0
#ifdef D1XD3D
#define BM_DIRECTX 1
#else
#ifdef __MSDOS__
#define BM_MODEX 1
#define BM_SVGA 2
#endif
#endif
#define BM_RGB15 3 //5 bits each r,g,b stored at 16 bits
#define BM_SVGA15 4
#ifdef OGL
#define BM_OGL 5
#endif
////=========================================================================
// System functions:
// setup and set mode. this creates a grs_screen structure and sets
// grd_curscreen to point to it. grs_curcanv points to this screen's
// canvas. Saves the current VGA state and screen mode.
int gr_init();
void gr_set_bitmap_data (grs_bitmap *bm, unsigned char *data);
void gr_enable_default_palette_loading();
void gr_disable_default_palette_loading();
// These 4 functions actuall change screen colors.
extern void gr_pal_fade_out(unsigned char * pal);
extern void gr_pal_fade_in(unsigned char * pal);
extern void gr_pal_clear();
extern void gr_pal_setblock( int start, int number, unsigned char * pal );
extern void gr_pal_getblock( int start, int number, unsigned char * pal );
//shut down the 2d. Restore the screen mode.
void gr_close();
// 0=Mode set OK
// 1=No VGA adapter installed
// 2=Program doesn't support this VESA granularity
// 3=Monitor doesn't support that VESA mode.:
// 4=Video card doesn't support that VESA mode.
// 5=No VESA driver found.
// 6=Bad Status after VESA call/
// 7=Not enough DOS memory to call VESA functions.
// 8=Error using DPMI.
// 9=Error setting logical line width.
// 10=Error allocating selector for A0000h
// 11=Not a valid mode support by gr.lib
// Returns one of the above without setting mode
int gr_check_mode(u_int32_t mode);
int gr_set_mode(u_int32_t mode);
//=========================================================================
// Canvas functions:
// Makes a new canvas. allocates memory for the canvas and its bitmap,
// including the raw pixel buffer.
grs_canvas *gr_create_canvas(int w, int h);
// Creates a canvas that is part of another canvas. this can be used to make
// a window on the screen. the canvas structure is malloc'd; the address of
// the raw pixel data is inherited from the parent canvas.
grs_canvas *gr_create_sub_canvas(grs_canvas *canv,int x,int y,int w, int h);
// Initialize the specified canvas. the raw pixel data buffer is passed as
// a parameter. no memory allocation is performed.
void gr_init_canvas(grs_canvas *canv,unsigned char *pixdata,int pixtype, int w,int h);
// Initialize the specified sub canvas. no memory allocation is performed.
void gr_init_sub_canvas(grs_canvas *New,grs_canvas *src,int x,int y,int w, int h);
// Free up the canvas and its pixel data.
void gr_free_canvas(grs_canvas *canv);
// Free up the canvas. do not free the pixel data, which belongs to the
// parent canvas.
void gr_free_sub_canvas(grs_canvas *canv);
// Clear the current canvas to the specified color
void gr_clear_canvas(int color);
//=========================================================================
// Bitmap functions:
// these are the two workhorses, the others just use these
extern void gr_init_bitmap( grs_bitmap *bm, int mode, int x, int y, int w, int h, int bytesperline, unsigned char * data );
extern void gr_init_sub_bitmap (grs_bitmap *bm, grs_bitmap *bmParent, int x, int y, int w, int h );
extern void gr_init_bitmap_alloc( grs_bitmap *bm, int mode, int x, int y, int w, int h, int bytesperline);
// Allocate a bitmap and its pixel data buffer.
grs_bitmap *gr_create_bitmap(int w,int h);
// Allocated a bitmap and makes its data be raw_data that is already somewhere.
grs_bitmap *gr_create_bitmap_raw(int w, int h, unsigned char * raw_data );
// Creates a bitmap which is part of another bitmap
grs_bitmap *gr_create_sub_bitmap(grs_bitmap *bm,int x,int y,int w, int h);
// Free the bitmap and its pixel data
void gr_free_bitmap(grs_bitmap *bm);
// Free the bitmap's data
void gr_free_bitmap_data (grs_bitmap *bm);
void gr_init_bitmap_data (grs_bitmap *bm);
// Free the bitmap, but not the pixel data buffer
void gr_free_sub_bitmap(grs_bitmap *bm);
void gr_bm_pixel( grs_bitmap * bm, int x, int y, unsigned char color );
void gr_bm_upixel( grs_bitmap * bm, int x, int y, unsigned char color );
void gr_bm_ubitblt( int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest);
void gr_bm_ubitbltm(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest);
void gr_bitblt_cockpit(grs_bitmap *bm);
void gr_update_buffer( void * sbuf1, void * sbuf2, void * dbuf, int size );
void gr_set_bitmap_flags (grs_bitmap *pbm, int flags);
void gr_set_transparent (grs_bitmap *pbm, int bTransparent);
void gr_set_super_transparent (grs_bitmap *pbm, int bTransparent);
void gr_set_bitmap_data (grs_bitmap *bm, unsigned char *data);
//=========================================================================
// Color functions:
// When this function is called, the guns are set to gr_palette, and
// the palette stays the same until gr_close is called
void gr_use_palette_table(char * filename );
//=========================================================================
// Drawing functions:
// For solid, XOR, or other fill modes.
void gr_set_drawmode(int mode);
// Sets the color in the current canvas. should be a macro
// Use: gr_setcolor(int color);
void gr_setcolor(int color);
// Draw a polygon into the current canvas in the current color and drawmode.
// verts points to an ordered list of x,y pairs. the polygon should be
// convex; a concave polygon will be handled in some reasonable manner,
// but not necessarily shaded as a concave polygon. It shouldn't hang.
// probably good solution is to shade from minx to maxx on each scan line.
// int should really be fix
void gr_poly(int nverts,int *verts);
void gr_upoly(int nverts,int *verts);
// Draws a point into the current canvas in the current color and drawmode.
void gr_pixel(int x,int y);
void gr_upixel(int x,int y);
// Gets a pixel;
unsigned char gr_gpixel( grs_bitmap * bitmap, int x, int y );
unsigned char gr_ugpixel( grs_bitmap * bitmap, int x, int y );
// Draws a line into the current canvas in the current color and drawmode.
int gr_line(fix x0,fix y0,fix x1,fix y1);
int gr_uline(fix x0,fix y0,fix x1,fix y1);
// Draws an anti-aliased line into the current canvas in the current color and drawmode.
int gr_aaline(fix x0,fix y0,fix x1,fix y1);
int gr_uaaline(fix x0,fix y0,fix x1,fix y1);
// Draw the bitmap into the current canvas at the specified location.
void gr_bitmap(int x,int y,grs_bitmap *bm);
void gr_ubitmap(int x,int y,grs_bitmap *bm);
inline void scale_line(sbyte *in, sbyte *out, int ilen, int olen);
void gr_bitmap_scale_to(grs_bitmap *src, grs_bitmap *dst);
void show_fullscr(grs_bitmap *bm);
// bitmap function with transparency
void gr_bitmapm( int x, int y, grs_bitmap *bm );
void gr_ubitmapm( int x, int y, grs_bitmap *bm );
// Draw a rectangle into the current canvas.
void gr_rect(int left,int top,int right,int bot);
void gr_urect(int left,int top,int right,int bot);
// Draw a filled circle
int gr_disk(fix x,fix y,fix r);
int gr_udisk(fix x,fix y,fix r);
// Draw an outline circle
int gr_circle(fix x,fix y,fix r);
int gr_ucircle(fix x,fix y,fix r);
// Draw an unfilled rectangle into the current canvas
void gr_box(int left,int top,int right,int bot);
void gr_ubox(int left,int top,int right,int bot);
void gr_scanline( int x1, int x2, int y );
void gr_uscanline( int x1, int x2, int y );
// Reads in a font file... current font set to this one.
grs_font * gr_init_font( char * fontfile );
void gr_close_font( grs_font * font );
// Writes a string using current font. Returns the next column after last char.
void gr_set_fontcolor( int fg, int bg );
void gr_set_curfont( grs_font * New );
int gr_string(int x, int y, char *s );
int gr_ustring(int x, int y, char *s );
int gr_printf( int x, int y, char * format, ... );
int gr_uprintf( int x, int y, char * format, ... );
void gr_get_string_size(char *s, int *string_width, int *string_height, int *average_width );
// From roller.c
void rotate_bitmap(grs_bitmap *bp, grs_point *vertbuf, int light_value);
// From scale.c
void scale_bitmap(grs_bitmap *bp, grs_point *vertbuf );
//===========================================================================
// Global variables
extern grs_canvas *grd_curcanv; //active canvas
extern grs_screen *grd_curscreen; //active screen
extern unsigned char Test_bitmap_data[64*64];
#define GWIDTH grd_curcanv->cv_bitmap.bm_w
#define GHEIGHT grd_curcanv->cv_bitmap.bm_h
#define SWIDTH (grd_curscreen->sc_w)
#define SHEIGHT (grd_curscreen->sc_h)
extern unsigned int FixDivide( unsigned int x, unsigned int y );
extern void gr_show_canvas( grs_canvas *canv );
extern void gr_set_current_canvas( grs_canvas *canv );
//flags for fonts
#define FT_COLOR 1
#define FT_PROPORTIONAL 2
#define FT_KERNED 4
// Special effects
extern void gr_snow_out(int num_dots);
extern void test_rotate_bitmap(void);
extern void rotate_bitmap(grs_bitmap *bp, grs_point *vertbuf, int light_value);
extern ubyte gr_palette[256*3];
extern ubyte gr_fade_table[256*GR_FADE_LEVELS];
extern ubyte gr_inverse_table[32*32*32];
extern ushort gr_palette_selector;
extern ushort gr_inverse_table_selector;
extern ushort gr_fade_table_selector;
// Remaps a bitmap into the current palette. If transparent_color is between 0 and 255
// then all occurances of that color are mapped to whatever color the 2d uses for
// transparency. This is normally used right after a call to iff_read_bitmap like
// this:
// iff_error = iff_read_bitmap(filename,new,BM_LINEAR,newpal);
// if (iff_error != IFF_NO_ERROR) Error("Can't load IFF file <%s>, error=%d",filename,iff_error);
// if ( iff_has_transparency )
// gr_remap_bitmap( new, newpal, iff_transparent_color );
// else
// gr_remap_bitmap( new, newpal, -1 );
extern void gr_remap_bitmap( grs_bitmap * bmp, ubyte * palette, int transparent_color, int super_transparent_color );
// Same as above, but searches using gr_find_closest_color which uses 18-bit accurracy
// instaed of 15bit when translating colors.
extern void gr_remap_bitmap_good( grs_bitmap * bmp, ubyte * palette, int transparent_color, int super_transparent_color );
extern void gr_palette_step_up( int r, int g, int b );
extern void gr_bitmap_check_transparency( grs_bitmap * bmp );
#ifdef BITMAP_SELECTOR
// Allocates a selector that has a base address at 'address' and length 'size'.
// Returns 0 if successful... BE SURE TO CHECK the return value since there
// is a limited number of selectors available!!!
extern int get_selector( void * address, int size, unsigned int * selector );
// Assigns a selector to a bitmap. Returns 0 if successful. BE SURE TO CHECK
// this return value since there is a limited number of selectors!!!!!!!
extern int gr_bitmap_assign_selector( grs_bitmap * bmp );
#endif
//#define GR_GETCOLOR(r,g,b) (gr_inverse_table[( (((r)&31)<<10) | (((g)&31)<<5) | ((b)&31) )])
//#define gr_getcolor(r,g,b) (gr_inverse_table[( (((r)&31)<<10) | (((g)&31)<<5) | ((b)&31) )])
//#define BM_XRGB(r,g,b) (gr_inverse_table[( (((r)&31)<<10) | (((g)&31)<<5) | ((b)&31) )])
#define BM_RGB(r,g,b) ( (((r)&31)<<10) | (((g)&31)<<5) | ((b)&31) )
#define BM_XRGB(r,g,b) gr_find_closest_color( (r)*2,(g)*2,(b)*2 )
#define GR_GETCOLOR(r,g,b) gr_find_closest_color( (r)*2,(g)*2,(b)*2 )
#define gr_getcolor(r,g,b) gr_find_closest_color( (r)*2,(g)*2,(b)*2 )
// Given: r,g,b, each in range of 0-63, return the color index that
// best matches the input.
int gr_find_closest_color( int r, int g, int b );
extern void gr_merge_textures( ubyte * lower, ubyte * upper, ubyte * dest );
extern void gr_merge_textures_1( ubyte * lower, ubyte * upper, ubyte * dest );
extern void gr_merge_textures_2( ubyte * lower, ubyte * upper, ubyte * dest );
extern void gr_merge_textures_3( ubyte * lower, ubyte * upper, ubyte * dest );
// gr.c
extern void gr_sync_display();
// bitmap.c
extern void build_colormap_good( ubyte * palette, ubyte * colormap, int * freq );
//extern void decode_data_asm(ubyte *data, int num_pixels, ubyte *colormap, int *count);
extern void gr_update();
//added 05/19/99 Matt Mueller - graphics locking stuff
#if (defined(TEST_GR_LOCK) || defined(GR_LOCK))
extern int gr_testlocklevel;
#define gr_dotestlock() gr_testlocklevel++
#define gr_dotestunlock() gr_testlocklevel--
#endif
#if (defined(TEST_GR_LOCK) && defined(GR_LOCK))
#include "mono.h"
#define gr_testlock() {if (gr_testlocklevel<=0) mprintf((0, "gr_testlock: NOT locked at " __FILE__ ":%i\n",__LINE__));}
#define gr_testunlock() {if (gr_testlocklevel>0) mprintf((0, "gr_testunlock: LOCKED at " __FILE__ ":%i\n",__LINE__));}
#else
#define gr_dotestlock()
#define gr_dotestunlock()
#define gr_testlock()
#define gr_testunlock()
#endif
#ifdef GR_LOCK
inline void gr_dolock(const char *file,int line);
#define gr_lock() gr_dolock(__FILE__,__LINE__)
inline void gr_dounlock(void);
#define gr_unlock() gr_dounlock()
#else
#define gr_lock() {gr_dotestlock();}
#define gr_unlock() {gr_dotestunlock();}
#endif
//end addition -MM
#endif //!_GR_H
//currently SDL and OGL are the only things that supports toggling fullscreen. otherwise add other checks to the #if -MPM
#if (defined(SDL_VIDEO) || defined(OGL))
#define GR_SUPPORTS_FULLSCREEN_TOGGLE
int gr_check_fullscreen(void);//must return 0 if windowed, 1 if fullscreen
int gr_toggle_fullscreen(void);//returns state after toggling (ie, same as if you had called check_fullscreen immediatly after)
#endif
//currently only OGL can toggle in the menus, because its screen data is not used (and stays in the same place). whereas software modes, toggling fullscreen would very likely make the data buffer point to a different location, and all the subbitmaps of it would have invalid addresses in them.
/*#ifdef OGL
#define GR_SUPPORTS_FULLSCREEN_MENU_TOGGLE
#endif*/ // ZICO - do not allow this, becuse windows does not like that
int gr_toggle_fullscreen_menu(void);//returns state after toggling (ie, same as if you had called check_fullscreen immediatly after)
//make this a define, since its used in several places
#define KEYS_GR_TOGGLE_FULLSCREEN KEY_CTRLED+KEY_SHIFTED+KEY_PADENTER: case KEY_ALTED+KEY_CTRLED+KEY_PADENTER: case KEY_ALTED+KEY_SHIFTED+KEY_PADENTER: case KEY_ALTED+KEY_ENTER
Reference in a new issue View git blame Copy permalink