first

Quake/gl_draw.c

@@ -0,0 +1,772 @@
+/*
+Copyright (C) 1996-2001 Id Software, Inc.
+Copyright (C) 2002-2009 John Fitzgibbons and others
+Copyright (C) 2007-2008 Kristian Duske
+Copyright (C) 2010-2014 QuakeSpasm developers
+
+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; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// draw.c -- 2d drawing
+
+#include "quakedef.h"
+
+//extern unsigned char d_15to8table[65536]; //johnfitz -- never used
+
+cvar_t		scr_conalpha = {"scr_conalpha", "0.5", CVAR_ARCHIVE}; //johnfitz
+
+qpic_t		*draw_disc;
+qpic_t		*draw_backtile;
+
+gltexture_t *char_texture; //johnfitz
+qpic_t		*pic_ovr, *pic_ins; //johnfitz -- new cursor handling
+qpic_t		*pic_nul; //johnfitz -- for missing gfx, don't crash
+
+//johnfitz -- new pics
+byte pic_ovr_data[8][8] =
+{
+	{255,255,255,255,255,255,255,255},
+	{255, 15, 15, 15, 15, 15, 15,255},
+	{255, 15, 15, 15, 15, 15, 15,  2},
+	{255, 15, 15, 15, 15, 15, 15,  2},
+	{255, 15, 15, 15, 15, 15, 15,  2},
+	{255, 15, 15, 15, 15, 15, 15,  2},
+	{255, 15, 15, 15, 15, 15, 15,  2},
+	{255,255,  2,  2,  2,  2,  2,  2},
+};
+
+byte pic_ins_data[9][8] =
+{
+	{ 15, 15,255,255,255,255,255,255},
+	{ 15, 15,  2,255,255,255,255,255},
+	{ 15, 15,  2,255,255,255,255,255},
+	{ 15, 15,  2,255,255,255,255,255},
+	{ 15, 15,  2,255,255,255,255,255},
+	{ 15, 15,  2,255,255,255,255,255},
+	{ 15, 15,  2,255,255,255,255,255},
+	{ 15, 15,  2,255,255,255,255,255},
+	{255,  2,  2,255,255,255,255,255},
+};
+
+byte pic_nul_data[8][8] =
+{
+	{252,252,252,252,  0,  0,  0,  0},
+	{252,252,252,252,  0,  0,  0,  0},
+	{252,252,252,252,  0,  0,  0,  0},
+	{252,252,252,252,  0,  0,  0,  0},
+	{  0,  0,  0,  0,252,252,252,252},
+	{  0,  0,  0,  0,252,252,252,252},
+	{  0,  0,  0,  0,252,252,252,252},
+	{  0,  0,  0,  0,252,252,252,252},
+};
+
+byte pic_stipple_data[8][8] =
+{
+	{255,  0,  0,  0,255,  0,  0,  0},
+	{  0,  0,255,  0,  0,  0,255,  0},
+	{255,  0,  0,  0,255,  0,  0,  0},
+	{  0,  0,255,  0,  0,  0,255,  0},
+	{255,  0,  0,  0,255,  0,  0,  0},
+	{  0,  0,255,  0,  0,  0,255,  0},
+	{255,  0,  0,  0,255,  0,  0,  0},
+	{  0,  0,255,  0,  0,  0,255,  0},
+};
+
+byte pic_crosshair_data[8][8] =
+{
+	{255,255,255,255,255,255,255,255},
+	{255,255,255,  8,  9,255,255,255},
+	{255,255,255,  6,  8,  2,255,255},
+	{255,  6,  8,  8,  6,  8,  8,255},
+	{255,255,  2,  8,  8,  2,  2,  2},
+	{255,255,255,  7,  8,  2,255,255},
+	{255,255,255,255,  2,  2,255,255},
+	{255,255,255,255,255,255,255,255},
+};
+//johnfitz
+
+typedef struct
+{
+	gltexture_t *gltexture;
+	float		sl, tl, sh, th;
+} glpic_t;
+
+canvastype currentcanvas = CANVAS_NONE; //johnfitz -- for GL_SetCanvas
+
+//==============================================================================
+//
+//  PIC CACHING
+//
+//==============================================================================
+
+typedef struct cachepic_s
+{
+	char		name[MAX_QPATH];
+	qpic_t		pic;
+	byte		padding[32];	// for appended glpic
+} cachepic_t;
+
+#define	MAX_CACHED_PICS		128
+cachepic_t	menu_cachepics[MAX_CACHED_PICS];
+int			menu_numcachepics;
+
+byte		menuplyr_pixels[4096];
+
+//  scrap allocation
+//  Allocate all the little status bar obejcts into a single texture
+//  to crutch up stupid hardware / drivers
+
+#define	MAX_SCRAPS		2
+#define	BLOCK_WIDTH		256
+#define	BLOCK_HEIGHT	256
+
+int			scrap_allocated[MAX_SCRAPS][BLOCK_WIDTH];
+byte		scrap_texels[MAX_SCRAPS][BLOCK_WIDTH*BLOCK_HEIGHT]; //johnfitz -- removed *4 after BLOCK_HEIGHT
+qboolean	scrap_dirty;
+gltexture_t	*scrap_textures[MAX_SCRAPS]; //johnfitz
+
+
+/*
+================
+Scrap_AllocBlock
+
+returns an index into scrap_texnums[] and the position inside it
+================
+*/
+int Scrap_AllocBlock (int w, int h, int *x, int *y)
+{
+	int		i, j;
+	int		best, best2;
+	int		texnum;
+
+	for (texnum=0 ; texnum<MAX_SCRAPS ; texnum++)
+	{
+		best = BLOCK_HEIGHT;
+
+		for (i=0 ; i<BLOCK_WIDTH-w ; i++)
+		{
+			best2 = 0;
+
+			for (j=0 ; j<w ; j++)
+			{
+				if (scrap_allocated[texnum][i+j] >= best)
+					break;
+				if (scrap_allocated[texnum][i+j] > best2)
+					best2 = scrap_allocated[texnum][i+j];
+			}
+			if (j == w)
+			{	// this is a valid spot
+				*x = i;
+				*y = best = best2;
+			}
+		}
+
+		if (best + h > BLOCK_HEIGHT)
+			continue;
+
+		for (i=0 ; i<w ; i++)
+			scrap_allocated[texnum][*x + i] = best + h;
+
+		return texnum;
+	}
+
+	Sys_Error ("Scrap_AllocBlock: full"); //johnfitz -- correct function name
+	return 0; //johnfitz -- shut up compiler
+}
+
+/*
+================
+Scrap_Upload -- johnfitz -- now uses TexMgr
+================
+*/
+void Scrap_Upload (void)
+{
+	char name[8];
+	int	i;
+
+	for (i=0; i<MAX_SCRAPS; i++)
+	{
+		sprintf (name, "scrap%i", i);
+		scrap_textures[i] = TexMgr_LoadImage (NULL, name, BLOCK_WIDTH, BLOCK_HEIGHT, SRC_INDEXED, scrap_texels[i],
+			"", (src_offset_t)scrap_texels[i], TEXPREF_ALPHA | TEXPREF_OVERWRITE | TEXPREF_NOPICMIP);
+	}
+
+	scrap_dirty = false;
+}
+
+/*
+================
+Draw_PicFromWad
+================
+*/
+qpic_t *Draw_PicFromWad (const char *name)
+{
+	qpic_t	*p;
+	glpic_t	gl;
+	src_offset_t offset; //johnfitz
+
+	p = (qpic_t *) W_GetLumpName (name);
+	if (!p) return pic_nul; //johnfitz
+
+	// load little ones into the scrap
+	if (p->width < 64 && p->height < 64)
+	{
+		int		x, y;
+		int		i, j, k;
+		int		texnum;
+
+		texnum = Scrap_AllocBlock (p->width, p->height, &x, &y);
+		scrap_dirty = true;
+		k = 0;
+		for (i=0 ; i<p->height ; i++)
+		{
+			for (j=0 ; j<p->width ; j++, k++)
+				scrap_texels[texnum][(y+i)*BLOCK_WIDTH + x + j] = p->data[k];
+		}
+		gl.gltexture = scrap_textures[texnum]; //johnfitz -- changed to an array
+		//johnfitz -- no longer go from 0.01 to 0.99
+		gl.sl = x/(float)BLOCK_WIDTH;
+		gl.sh = (x+p->width)/(float)BLOCK_WIDTH;
+		gl.tl = y/(float)BLOCK_WIDTH;
+		gl.th = (y+p->height)/(float)BLOCK_WIDTH;
+	}
+	else
+	{
+		char texturename[64]; //johnfitz
+		q_snprintf (texturename, sizeof(texturename), "%s:%s", WADFILENAME, name); //johnfitz
+
+		offset = (src_offset_t)p - (src_offset_t)wad_base + sizeof(int)*2; //johnfitz
+
+		gl.gltexture = TexMgr_LoadImage (NULL, texturename, p->width, p->height, SRC_INDEXED, p->data, WADFILENAME,
+										  offset, TEXPREF_ALPHA | TEXPREF_PAD | TEXPREF_NOPICMIP); //johnfitz -- TexMgr
+		gl.sl = 0;
+		gl.sh = (float)p->width/(float)TexMgr_PadConditional(p->width); //johnfitz
+		gl.tl = 0;
+		gl.th = (float)p->height/(float)TexMgr_PadConditional(p->height); //johnfitz
+	}
+
+	memcpy (p->data, &gl, sizeof(glpic_t));
+
+	return p;
+}
+
+/*
+================
+Draw_CachePic
+================
+*/
+qpic_t	*Draw_CachePic (const char *path)
+{
+	cachepic_t	*pic;
+	int			i;
+	qpic_t		*dat;
+	glpic_t		gl;
+
+	for (pic=menu_cachepics, i=0 ; i<menu_numcachepics ; pic++, i++)
+	{
+		if (!strcmp (path, pic->name))
+			return &pic->pic;
+	}
+	if (menu_numcachepics == MAX_CACHED_PICS)
+		Sys_Error ("menu_numcachepics == MAX_CACHED_PICS");
+	menu_numcachepics++;
+	strcpy (pic->name, path);
+
+//
+// load the pic from disk
+//
+	dat = (qpic_t *)COM_LoadTempFile (path, NULL);
+	if (!dat)
+		Sys_Error ("Draw_CachePic: failed to load %s", path);
+	SwapPic (dat);
+
+	// HACK HACK HACK --- we need to keep the bytes for
+	// the translatable player picture just for the menu
+	// configuration dialog
+	if (!strcmp (path, "gfx/menuplyr.lmp"))
+		memcpy (menuplyr_pixels, dat->data, dat->width*dat->height);
+
+	pic->pic.width = dat->width;
+	pic->pic.height = dat->height;
+
+	gl.gltexture = TexMgr_LoadImage (NULL, path, dat->width, dat->height, SRC_INDEXED, dat->data, path,
+									  sizeof(int)*2, TEXPREF_ALPHA | TEXPREF_PAD | TEXPREF_NOPICMIP); //johnfitz -- TexMgr
+	gl.sl = 0;
+	gl.sh = (float)dat->width/(float)TexMgr_PadConditional(dat->width); //johnfitz
+	gl.tl = 0;
+	gl.th = (float)dat->height/(float)TexMgr_PadConditional(dat->height); //johnfitz
+	memcpy (pic->pic.data, &gl, sizeof(glpic_t));
+
+	return &pic->pic;
+}
+
+/*
+================
+Draw_MakePic -- johnfitz -- generate pics from internal data
+================
+*/
+qpic_t *Draw_MakePic (const char *name, int width, int height, byte *data)
+{
+	int flags = TEXPREF_NEAREST | TEXPREF_ALPHA | TEXPREF_PERSIST | TEXPREF_NOPICMIP | TEXPREF_PAD;
+	qpic_t		*pic;
+	glpic_t		gl;
+
+	pic = (qpic_t *) Hunk_Alloc (sizeof(qpic_t) - 4 + sizeof (glpic_t));
+	pic->width = width;
+	pic->height = height;
+
+	gl.gltexture = TexMgr_LoadImage (NULL, name, width, height, SRC_INDEXED, data, "", (src_offset_t)data, flags);
+	gl.sl = 0;
+	gl.sh = (float)width/(float)TexMgr_PadConditional(width);
+	gl.tl = 0;
+	gl.th = (float)height/(float)TexMgr_PadConditional(height);
+	memcpy (pic->data, &gl, sizeof(glpic_t));
+
+	return pic;
+}
+
+//==============================================================================
+//
+//  INIT
+//
+//==============================================================================
+
+/*
+===============
+Draw_LoadPics -- johnfitz
+===============
+*/
+void Draw_LoadPics (void)
+{
+	byte		*data;
+	src_offset_t	offset;
+
+	data = (byte *) W_GetLumpName ("conchars");
+	if (!data) Sys_Error ("Draw_LoadPics: couldn't load conchars");
+	offset = (src_offset_t)data - (src_offset_t)wad_base;
+	char_texture = TexMgr_LoadImage (NULL, WADFILENAME":conchars", 128, 128, SRC_INDEXED, data,
+		WADFILENAME, offset, TEXPREF_ALPHA | TEXPREF_NEAREST | TEXPREF_NOPICMIP | TEXPREF_CONCHARS);
+
+	draw_disc = Draw_PicFromWad ("disc");
+	draw_backtile = Draw_PicFromWad ("backtile");
+}
+
+/*
+===============
+Draw_NewGame -- johnfitz
+===============
+*/
+void Draw_NewGame (void)
+{
+	cachepic_t	*pic;
+	int			i;
+
+	// empty scrap and reallocate gltextures
+	memset(scrap_allocated, 0, sizeof(scrap_allocated));
+	memset(scrap_texels, 255, sizeof(scrap_texels));
+
+	Scrap_Upload (); //creates 2 empty gltextures
+
+	// reload wad pics
+	W_LoadWadFile (); //johnfitz -- filename is now hard-coded for honesty
+	Draw_LoadPics ();
+	SCR_LoadPics ();
+	Sbar_LoadPics ();
+
+	// empty lmp cache
+	for (pic = menu_cachepics, i = 0; i < menu_numcachepics; pic++, i++)
+		pic->name[0] = 0;
+	menu_numcachepics = 0;
+}
+
+/*
+===============
+Draw_Init -- johnfitz -- rewritten
+===============
+*/
+void Draw_Init (void)
+{
+	Cvar_RegisterVariable (&scr_conalpha);
+
+	// clear scrap and allocate gltextures
+	memset(scrap_allocated, 0, sizeof(scrap_allocated));
+	memset(scrap_texels, 255, sizeof(scrap_texels));
+
+	Scrap_Upload (); //creates 2 empty textures
+
+	// create internal pics
+	pic_ins = Draw_MakePic ("ins", 8, 9, &pic_ins_data[0][0]);
+	pic_ovr = Draw_MakePic ("ovr", 8, 8, &pic_ovr_data[0][0]);
+	pic_nul = Draw_MakePic ("nul", 8, 8, &pic_nul_data[0][0]);
+
+	// load game pics
+	Draw_LoadPics ();
+}
+
+//==============================================================================
+//
+//  2D DRAWING
+//
+//==============================================================================
+
+/*
+================
+Draw_CharacterQuad -- johnfitz -- seperate function to spit out verts
+================
+*/
+void Draw_CharacterQuad (int x, int y, char num)
+{
+	int				row, col;
+	float			frow, fcol, size;
+
+	row = num>>4;
+	col = num&15;
+
+	frow = row*0.0625;
+	fcol = col*0.0625;
+	size = 0.0625;
+
+	glTexCoord2f (fcol, frow);
+	glVertex2f (x, y);
+	glTexCoord2f (fcol + size, frow);
+	glVertex2f (x+8, y);
+	glTexCoord2f (fcol + size, frow + size);
+	glVertex2f (x+8, y+8);
+	glTexCoord2f (fcol, frow + size);
+	glVertex2f (x, y+8);
+}
+
+/*
+================
+Draw_Character -- johnfitz -- modified to call Draw_CharacterQuad
+================
+*/
+void Draw_Character (int x, int y, int num)
+{
+	if (y <= -8)
+		return;			// totally off screen
+
+	num &= 255;
+
+	if (num == 32)
+		return; //don't waste verts on spaces
+
+	GL_Bind (char_texture);
+	glBegin (GL_QUADS);
+
+	Draw_CharacterQuad (x, y, (char) num);
+
+	glEnd ();
+}
+
+/*
+================
+Draw_String -- johnfitz -- modified to call Draw_CharacterQuad
+================
+*/
+void Draw_String (int x, int y, const char *str)
+{
+	if (y <= -8)
+		return;			// totally off screen
+
+	GL_Bind (char_texture);
+	glBegin (GL_QUADS);
+
+	while (*str)
+	{
+		if (*str != 32) //don't waste verts on spaces
+			Draw_CharacterQuad (x, y, *str);
+		str++;
+		x += 8;
+	}
+
+	glEnd ();
+}
+
+/*
+=============
+Draw_Pic -- johnfitz -- modified
+=============
+*/
+void Draw_Pic (int x, int y, qpic_t *pic)
+{
+	glpic_t			*gl;
+
+	if (scrap_dirty)
+		Scrap_Upload ();
+	gl = (glpic_t *)pic->data;
+	GL_Bind (gl->gltexture);
+	glBegin (GL_QUADS);
+	glTexCoord2f (gl->sl, gl->tl);
+	glVertex2f (x, y);
+	glTexCoord2f (gl->sh, gl->tl);
+	glVertex2f (x+pic->width, y);
+	glTexCoord2f (gl->sh, gl->th);
+	glVertex2f (x+pic->width, y+pic->height);
+	glTexCoord2f (gl->sl, gl->th);
+	glVertex2f (x, y+pic->height);
+	glEnd ();
+}
+
+/*
+=============
+Draw_TransPicTranslate -- johnfitz -- rewritten to use texmgr to do translation
+
+Only used for the player color selection menu
+=============
+*/
+void Draw_TransPicTranslate (int x, int y, qpic_t *pic, int top, int bottom)
+{
+	static int oldtop = -2;
+	static int oldbottom = -2;
+
+	if (top != oldtop || bottom != oldbottom)
+	{
+		glpic_t *p = (glpic_t *)pic->data;
+		gltexture_t *glt = p->gltexture;
+		oldtop = top;
+		oldbottom = bottom;
+		TexMgr_ReloadImage (glt, top, bottom);
+	}
+	Draw_Pic (x, y, pic);
+}
+
+/*
+================
+Draw_ConsoleBackground -- johnfitz -- rewritten
+================
+*/
+void Draw_ConsoleBackground (void)
+{
+	qpic_t *pic;
+	float alpha;
+
+	pic = Draw_CachePic ("gfx/conback.lmp");
+	pic->width = vid.conwidth;
+	pic->height = vid.conheight;
+
+	alpha = (con_forcedup) ? 1.0f : scr_conalpha.value;
+
+	GL_SetCanvas (CANVAS_CONSOLE); //in case this is called from weird places
+
+	if (alpha > 0.0f)
+	{
+		if (alpha < 1.0f)
+		{
+			glEnable (GL_BLEND);
+			glColor4f (1,1,1,alpha);
+			glDisable (GL_ALPHA_TEST);
+			glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+		}
+
+		Draw_Pic (0, 0, pic);
+
+		if (alpha < 1.0f)
+		{
+			glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+			glEnable (GL_ALPHA_TEST);
+			glDisable (GL_BLEND);
+			glColor4f (1,1,1,1);
+		}
+	}
+}
+
+
+/*
+=============
+Draw_TileClear
+
+This repeats a 64*64 tile graphic to fill the screen around a sized down
+refresh window.
+=============
+*/
+void Draw_TileClear (int x, int y, int w, int h)
+{
+	glpic_t	*gl;
+
+	gl = (glpic_t *)draw_backtile->data;
+
+	glColor3f (1,1,1);
+	GL_Bind (gl->gltexture);
+	glBegin (GL_QUADS);
+	glTexCoord2f (x/64.0, y/64.0);
+	glVertex2f (x, y);
+	glTexCoord2f ( (x+w)/64.0, y/64.0);
+	glVertex2f (x+w, y);
+	glTexCoord2f ( (x+w)/64.0, (y+h)/64.0);
+	glVertex2f (x+w, y+h);
+	glTexCoord2f ( x/64.0, (y+h)/64.0 );
+	glVertex2f (x, y+h);
+	glEnd ();
+}
+
+/*
+=============
+Draw_Fill
+
+Fills a box of pixels with a single color
+=============
+*/
+void Draw_Fill (int x, int y, int w, int h, int c, float alpha) //johnfitz -- added alpha
+{
+	byte *pal = (byte *)d_8to24table; //johnfitz -- use d_8to24table instead of host_basepal
+
+	glDisable (GL_TEXTURE_2D);
+	glEnable (GL_BLEND); //johnfitz -- for alpha
+	glDisable (GL_ALPHA_TEST); //johnfitz -- for alpha
+	glColor4f (pal[c*4]/255.0, pal[c*4+1]/255.0, pal[c*4+2]/255.0, alpha); //johnfitz -- added alpha
+
+	glBegin (GL_QUADS);
+	glVertex2f (x,y);
+	glVertex2f (x+w, y);
+	glVertex2f (x+w, y+h);
+	glVertex2f (x, y+h);
+	glEnd ();
+
+	glColor3f (1,1,1);
+	glDisable (GL_BLEND); //johnfitz -- for alpha
+	glEnable (GL_ALPHA_TEST); //johnfitz -- for alpha
+	glEnable (GL_TEXTURE_2D);
+}
+
+/*
+================
+Draw_FadeScreen -- johnfitz -- revised
+================
+*/
+void Draw_FadeScreen (void)
+{
+	GL_SetCanvas (CANVAS_DEFAULT);
+
+	glEnable (GL_BLEND);
+	glDisable (GL_ALPHA_TEST);
+	glDisable (GL_TEXTURE_2D);
+	glColor4f (0, 0, 0, 0.5);
+	glBegin (GL_QUADS);
+
+	glVertex2f (0,0);
+	glVertex2f (glwidth, 0);
+	glVertex2f (glwidth, glheight);
+	glVertex2f (0, glheight);
+
+	glEnd ();
+	glColor4f (1,1,1,1);
+	glEnable (GL_TEXTURE_2D);
+	glEnable (GL_ALPHA_TEST);
+	glDisable (GL_BLEND);
+
+	Sbar_Changed();
+}
+
+/*
+================
+GL_SetCanvas -- johnfitz -- support various canvas types
+================
+*/
+void GL_SetCanvas (canvastype newcanvas)
+{
+	extern vrect_t scr_vrect;
+	float s;
+	int lines;
+
+	if (newcanvas == currentcanvas)
+		return;
+
+	currentcanvas = newcanvas;
+
+	glMatrixMode(GL_PROJECTION);
+	glLoadIdentity ();
+
+	switch(newcanvas)
+	{
+	case CANVAS_DEFAULT:
+		glOrtho (0, glwidth, glheight, 0, -99999, 99999);
+		glViewport (glx, gly, glwidth, glheight);
+		break;
+	case CANVAS_CONSOLE:
+		lines = vid.conheight - (scr_con_current * vid.conheight / glheight);
+		glOrtho (0, vid.conwidth, vid.conheight + lines, lines, -99999, 99999);
+		glViewport (glx, gly, glwidth, glheight);
+		break;
+	case CANVAS_MENU:
+		s = q_min((float)glwidth / 320.0f, (float)glheight / 200.0f);
+		s = CLAMP (1.0f, scr_menuscale.value, s);
+		// ericw -- doubled width to 640 to accommodate long keybindings
+		glOrtho (0, 640, 200, 0, -99999, 99999);
+		glViewport (glx + (glwidth - 320*s) / 2, gly + (glheight - 200*s) / 2, 640*s, 200*s);
+		break;
+	case CANVAS_SBAR:
+		s = CLAMP (1.0f, scr_sbarscale.value, (float)glwidth / 320.0f);
+		if (cl.gametype == GAME_DEATHMATCH)
+		{
+			glOrtho (0, glwidth / s, 48, 0, -99999, 99999);
+			glViewport (glx, gly, glwidth, 48*s);
+		}
+		else
+		{
+			glOrtho (0, 320, 48, 0, -99999, 99999);
+			glViewport (glx + (glwidth - 320*s) / 2, gly, 320*s, 48*s);
+		}
+		break;
+	case CANVAS_WARPIMAGE:
+		glOrtho (0, 128, 0, 128, -99999, 99999);
+		glViewport (glx, gly+glheight-gl_warpimagesize, gl_warpimagesize, gl_warpimagesize);
+		break;
+	case CANVAS_CROSSHAIR: //0,0 is center of viewport
+		s = CLAMP (1.0f, scr_crosshairscale.value, 10.0f);
+		glOrtho (scr_vrect.width/-2/s, scr_vrect.width/2/s, scr_vrect.height/2/s, scr_vrect.height/-2/s, -99999, 99999);
+		glViewport (scr_vrect.x, glheight - scr_vrect.y - scr_vrect.height, scr_vrect.width & ~1, scr_vrect.height & ~1);
+		break;
+	case CANVAS_BOTTOMLEFT: //used by devstats
+		s = (float)glwidth/vid.conwidth; //use console scale
+		glOrtho (0, 320, 200, 0, -99999, 99999);
+		glViewport (glx, gly, 320*s, 200*s);
+		break;
+	case CANVAS_BOTTOMRIGHT: //used by fps/clock
+		s = (float)glwidth/vid.conwidth; //use console scale
+		glOrtho (0, 320, 200, 0, -99999, 99999);
+		glViewport (glx+glwidth-320*s, gly, 320*s, 200*s);
+		break;
+	case CANVAS_TOPRIGHT: //used by disc
+		s = 1;
+		glOrtho (0, 320, 200, 0, -99999, 99999);
+		glViewport (glx+glwidth-320*s, gly+glheight-200*s, 320*s, 200*s);
+		break;
+	default:
+		Sys_Error ("GL_SetCanvas: bad canvas type");
+	}
+
+	glMatrixMode(GL_MODELVIEW);
+	glLoadIdentity ();
+}
+
+/*
+================
+GL_Set2D -- johnfitz -- rewritten
+================
+*/
+void GL_Set2D (void)
+{
+	currentcanvas = CANVAS_INVALID;
+	GL_SetCanvas (CANVAS_DEFAULT);
+
+	glDisable (GL_DEPTH_TEST);
+	glDisable (GL_CULL_FACE);
+	glDisable (GL_BLEND);
+	glEnable (GL_ALPHA_TEST);
+	glColor4f (1,1,1,1);
+}