2006-03-20 16:43:15 +00:00
/*
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 .
*/
/*
*
* Definitions for graphics lib .
*
*/
# ifndef _GR_H
# define _GR_H
2006-08-13 15:52:49 +00:00
# include "cfile.h"
2008-01-02 03:37:13 +00:00
# include "pstypes.h"
2006-03-20 16:43:15 +00:00
# include "fix.h"
2008-03-16 08:11:08 +00:00
extern int HiresGFXAvailable ;
2006-03-20 16:43:15 +00:00
// #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
2008-03-16 08:11:08 +00:00
# define HIRESMODE HiresGFXAvailable // descent.pig either contains hires or lowres graphics, not both
2006-11-28 08:59:16 +00:00
# define MAX_BMP_SIZE(width, height) (4 + ((width) + 2) * (height))
2006-03-20 16:43:15 +00:00
2007-01-25 09:56:05 +00:00
# define SCRNS_DIR "screenshots / "
2006-03-20 16:43:15 +00:00
extern int Gr_scanline_darkening_level ;
typedef struct _grs_point {
fix x , y ;
} grs_point ;
//old font structure, could not add new items to it without screwing up gr_init_font
typedef struct _grs_font {
2006-08-13 15:52:49 +00:00
int16_t ft_w , ft_h ; // Width and height in pixels
int16_t ft_flags ; // Proportional?
2006-03-20 16:43:15 +00:00
int16_t ft_baseline ; //
2006-08-13 15:52:49 +00:00
ubyte ft_minchar , // The first and last chars defined by
ft_maxchar ; // This font
2006-03-20 16:43:15 +00:00
int16_t ft_bytewidth ; // Width in unsigned chars
2006-08-13 15:52:49 +00:00
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)
2006-03-20 16:43:15 +00:00
u_int32_t ft_kerndata ; // Array of kerning triplet data
}
old_grs_font ;
# define BM_LINEAR 0
2008-03-16 08:11:08 +00:00
# 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_RLE_BIG 32 // for bitmaps that RLE to > 255 per row (i.e. cockpits)
# define BM_FLAG_COCKPIT_TRANSPARENT 64 // for cockpit - render black parts as alpha
2006-03-20 16:43:15 +00:00
typedef struct _grs_bitmap {
short bm_x , bm_y ; // Offset from parent's origin
short bm_w , bm_h ; // width,height
2006-10-06 14:41:31 +00:00
sbyte bm_type ; // 0=Linear, 1=ModeX, 2=SVGA
sbyte bm_flags ; // bit 0 on means it has transparency.
2006-03-20 16:43:15 +00:00
// 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.
2006-10-06 14:41:31 +00:00
sbyte unused ; // to 4-byte align.
2006-03-20 16:43:15 +00:00
# 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 ;
# 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 BM_LINEAR 0
# 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 ( ) ;
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 ) ;
2007-02-06 19:23:33 +00:00
inline void scale_line ( unsigned char * in , unsigned char * out , int ilen , int olen ) ;
2006-03-20 16:43:15 +00:00
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_curfont ( grs_font * New ) ;
2008-02-24 14:41:27 +00:00
void gr_set_fontcolor ( int fg_color , int bg_color ) ;
2006-03-20 16:43:15 +00:00
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 ) ;
2008-02-24 14:41:27 +00:00
// 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 ) ;
2006-03-20 16:43:15 +00:00
//===========================================================================
// 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_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 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 )
// 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);
2007-03-22 14:15:46 +00:00
extern void gr_flip ( void ) ;
extern void gr_set_draw_buffer ( int buf ) ;
2006-03-20 16:43:15 +00:00
//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
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)
//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