Subversion Repositories Kolibri OS

/*

Copyright (C) 1996-1997 Id Software, Inc.

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.

*/

// screen.c -- master for refresh, status bar, console, chat, notify, etc

#include "quakedef.h"

#include "r_local.h"

// only the refresh window will be updated unless these variables are flagged

int			scr_copytop;

int			scr_copyeverything;

float		scr_con_current;

float		scr_conlines;		// lines of console to display

float		oldscreensize, oldfov;

cvar_t		scr_viewsize = {"viewsize","100", true};

cvar_t		scr_fov = {"fov","90"};	// 10 - 170

cvar_t		scr_conspeed = {"scr_conspeed","300"};

cvar_t		scr_centertime = {"scr_centertime","2"};

cvar_t		scr_showram = {"showram","1"};

cvar_t		scr_showturtle = {"showturtle","0"};

cvar_t		scr_showpause = {"showpause","1"};

cvar_t		scr_printspeed = {"scr_printspeed","8"};

qboolean	scr_initialized;		// ready to draw

qpic_t		*scr_ram;

qpic_t		*scr_net;

qpic_t		*scr_turtle;

int			scr_fullupdate;

int			clearconsole;

int			clearnotify;

viddef_t	vid;				// global video state

vrect_t		*pconupdate;

vrect_t		scr_vrect;

qboolean	scr_disabled_for_loading;

qboolean	scr_drawloading;

float		scr_disabled_time;

qboolean	scr_skipupdate;

qboolean	block_drawing;

void SCR_ScreenShot_f (void);

/*

===============================================================================

CENTER PRINTING

===============================================================================

*/

char		scr_centerstring[1024];

float		scr_centertime_start;	// for slow victory printing

float		scr_centertime_off;

int			scr_center_lines;

int			scr_erase_lines;

int			scr_erase_center;

/*

==============

SCR_CenterPrint

Called for important messages that should stay in the center of the screen

for a few moments

==============

*/

void SCR_CenterPrint (char *str)

{

	strncpy (scr_centerstring, str, sizeof(scr_centerstring)-1);

	scr_centertime_off = scr_centertime.value;

	scr_centertime_start = cl.time;

// count the number of lines for centering

	scr_center_lines = 1;

	while (*str)

	{

		if (*str == '\n')

			scr_center_lines++;

		str++;

	}

}

void SCR_EraseCenterString (void)

{

	int		y;

	if (scr_erase_center++ > vid.numpages)

	{

		scr_erase_lines = 0;

		return;

	}

	if (scr_center_lines <= 4)

		y = vid.height*0.35;

	else

		y = 48;

	scr_copytop = 1;

	Draw_TileClear (0, y,vid.width, 8*scr_erase_lines);

}

void SCR_DrawCenterString (void)

{

	char	*start;

	int		l;

	int		j;

	int		x, y;

	int		remaining;

// the finale prints the characters one at a time

	if (cl.intermission)

		remaining = scr_printspeed.value * (cl.time - scr_centertime_start);

	else

		remaining = 9999;

	scr_erase_center = 0;

	start = scr_centerstring;

	if (scr_center_lines <= 4)

		y = vid.height*0.35;

	else

		y = 48;

	do

	{

	// scan the width of the line

		for (l=0 ; l<40 ; l++)

			if (start[l] == '\n' || !start[l])

				break;

		x = (vid.width - l*8)/2;

		for (j=0 ; j

		{

			Draw_Character (x, y, start[j]);

			if (!remaining--)

				return;

		}

		y += 8;

		while (*start && *start != '\n')

			start++;

		if (!*start)

			break;

		start++;		// skip the \n

	} while (1);

}

void SCR_CheckDrawCenterString (void)

{

	scr_copytop = 1;

	if (scr_center_lines > scr_erase_lines)

		scr_erase_lines = scr_center_lines;

	scr_centertime_off -= host_frametime;

	if (scr_centertime_off <= 0 && !cl.intermission)

		return;

	if (key_dest != key_game)

		return;

	SCR_DrawCenterString ();

}

//=============================================================================

/*

====================

CalcFov

====================

*/

float CalcFov (float fov_x, float width, float height)

{

        float   a;

        float   x;

        if (fov_x < 1 || fov_x > 179)

                Sys_Error ("Bad fov: %f", fov_x);

        x = width/tan(fov_x/360*M_PI);

        a = atan (height/x);

        a = a*360/M_PI;

        return a;

}

/*

=================

SCR_CalcRefdef

Must be called whenever vid changes

Internal use only

=================

*/

static void SCR_CalcRefdef (void)

{

	vrect_t		vrect;

	float		size;

	scr_fullupdate = 0;		// force a background redraw

	vid.recalc_refdef = 0;

// force the status bar to redraw

	Sbar_Changed ();

//========================================

// bound viewsize

	if (scr_viewsize.value < 30)

		Cvar_Set ("viewsize","30");

	if (scr_viewsize.value > 120)

		Cvar_Set ("viewsize","120");

// bound field of view

	if (scr_fov.value < 10)

		Cvar_Set ("fov","10");

	if (scr_fov.value > 170)

		Cvar_Set ("fov","170");

	r_refdef.fov_x = scr_fov.value;

	r_refdef.fov_y = CalcFov (r_refdef.fov_x, r_refdef.vrect.width, r_refdef.vrect.height);

// intermission is always full screen

	if (cl.intermission)

		size = 120;

	else

		size = scr_viewsize.value;

	if (size >= 120)

		sb_lines = 0;		// no status bar at all

	else if (size >= 110)

		sb_lines = 24;		// no inventory

	else

		sb_lines = 24+16+8;

// these calculations mirror those in R_Init() for r_refdef, but take no

// account of water warping

	vrect.x = 0;

	vrect.y = 0;

	vrect.width = vid.width;

	vrect.height = vid.height;

	R_SetVrect (&vrect, &scr_vrect, sb_lines);

// guard against going from one mode to another that's less than half the

// vertical resolution

	if (scr_con_current > vid.height)

		scr_con_current = vid.height;

// notify the refresh of the change

	R_ViewChanged (&vrect, sb_lines, vid.aspect);

}

/*

=================

SCR_SizeUp_f

Keybinding command

=================

*/

void SCR_SizeUp_f (void)

{

	Cvar_SetValue ("viewsize",scr_viewsize.value+10);

	vid.recalc_refdef = 1;

}

/*

=================

SCR_SizeDown_f

Keybinding command

=================

*/

void SCR_SizeDown_f (void)

{

	Cvar_SetValue ("viewsize",scr_viewsize.value-10);

	vid.recalc_refdef = 1;

}

//============================================================================

/*

==================

SCR_Init

==================

*/

void SCR_Init (void)

{

	Cvar_RegisterVariable (&scr_fov);

	Cvar_RegisterVariable (&scr_viewsize);

	Cvar_RegisterVariable (&scr_conspeed);

	Cvar_RegisterVariable (&scr_showram);

	Cvar_RegisterVariable (&scr_showturtle);

	Cvar_RegisterVariable (&scr_showpause);

	Cvar_RegisterVariable (&scr_centertime);

	Cvar_RegisterVariable (&scr_printspeed);

//

// register our commands

//

	Cmd_AddCommand ("screenshot",SCR_ScreenShot_f);

	Cmd_AddCommand ("sizeup",SCR_SizeUp_f);

	Cmd_AddCommand ("sizedown",SCR_SizeDown_f);

	scr_ram = Draw_PicFromWad ("ram");

	scr_net = Draw_PicFromWad ("net");

	scr_turtle = Draw_PicFromWad ("turtle");

	scr_initialized = true;

}

/*

==============

SCR_DrawRam

==============

*/

void SCR_DrawRam (void)

{

	if (!scr_showram.value)

		return;

	if (!r_cache_thrash)

		return;

	Draw_Pic (scr_vrect.x+32, scr_vrect.y, scr_ram);

}

/*

==============

SCR_DrawTurtle

==============

*/

void SCR_DrawTurtle (void)

{

	static int	count;

	if (!scr_showturtle.value)

		return;

	if (host_frametime < 0.1)

	{

		count = 0;

		return;

	}

	count++;

	if (count < 3)

		return;

	Draw_Pic (scr_vrect.x, scr_vrect.y, scr_turtle);

}

/*

==============

SCR_DrawNet

==============

*/

void SCR_DrawNet (void)

{

	if (realtime - cl.last_received_message < 0.3)

		return;

	if (cls.demoplayback)

		return;

	Draw_Pic (scr_vrect.x+64, scr_vrect.y, scr_net);

}

/*

==============

DrawPause

==============

*/

void SCR_DrawPause (void)

{

	qpic_t	*pic;

	if (!scr_showpause.value)		// turn off for screenshots

		return;

	if (!cl.paused)

		return;

	pic = Draw_CachePic ("gfx/pause.lmp");

	Draw_Pic ( (vid.width - pic->width)/2,

		(vid.height - 48 - pic->height)/2, pic);

}

/*

==============

SCR_DrawLoading

==============

*/

void SCR_DrawLoading (void)

{

	qpic_t	*pic;

	if (!scr_drawloading)

		return;

	pic = Draw_CachePic ("gfx/loading.lmp");

	Draw_Pic ( (vid.width - pic->width)/2,

		(vid.height - 48 - pic->height)/2, pic);

}

//=============================================================================

/*

==================

SCR_SetUpToDrawConsole

==================

*/

void SCR_SetUpToDrawConsole (void)

{

	Con_CheckResize ();

	if (scr_drawloading)

		return;		// never a console with loading plaque

// decide on the height of the console

	con_forcedup = !cl.worldmodel || cls.signon != SIGNONS;

	if (con_forcedup)

	{

		scr_conlines = vid.height;		// full screen

		scr_con_current = scr_conlines;

	}

	else if (key_dest == key_console)

		scr_conlines = vid.height/2;	// half screen

	else

		scr_conlines = 0;				// none visible

	if (scr_conlines < scr_con_current)

	{

		scr_con_current -= scr_conspeed.value*host_frametime;

		if (scr_conlines > scr_con_current)

			scr_con_current = scr_conlines;

	}

	else if (scr_conlines > scr_con_current)

	{

		scr_con_current += scr_conspeed.value*host_frametime;

		if (scr_conlines < scr_con_current)

			scr_con_current = scr_conlines;

	}

	if (clearconsole++ < vid.numpages)

	{

		scr_copytop = 1;

		Draw_TileClear (0,(int)scr_con_current,vid.width, vid.height - (int)scr_con_current);

		Sbar_Changed ();

	}

	else if (clearnotify++ < vid.numpages)

	{

		scr_copytop = 1;

		Draw_TileClear (0,0,vid.width, con_notifylines);

	}

	else

		con_notifylines = 0;

}

/*

==================

SCR_DrawConsole

==================

*/

void SCR_DrawConsole (void)

{

	if (scr_con_current)

	{

		scr_copyeverything = 1;

		Con_DrawConsole (scr_con_current, true);

		clearconsole = 0;

	}

	else

	{

		if (key_dest == key_game || key_dest == key_message)

			Con_DrawNotify ();	// only draw notify in game

	}

}

/*

==============================================================================

						SCREEN SHOTS

==============================================================================

*/

typedef struct

{

    char	manufacturer;

    char	version;

    char	encoding;

    char	bits_per_pixel;

    unsigned short	xmin,ymin,xmax,ymax;

    unsigned short	hres,vres;

    unsigned char	palette[48];

    char	reserved;

    char	color_planes;

    unsigned short	bytes_per_line;

    unsigned short	palette_type;

    char	filler[58];

    unsigned char	data;			// unbounded

} pcx_t;

/*

==============

WritePCXfile

==============

*/

void WritePCXfile (char *filename, byte *data, int width, int height,

	int rowbytes, byte *palette)

{

	int		i, j, length;

	pcx_t	*pcx;

	byte		*pack;

	pcx = Hunk_TempAlloc (width*height*2+1000);

	if (pcx == NULL)

	{

		Con_Printf("SCR_ScreenShot_f: not enough memory\n");

		return;

	}

	pcx->manufacturer = 0x0a;	// PCX id

	pcx->version = 5;			// 256 color

 	pcx->encoding = 1;		// uncompressed

	pcx->bits_per_pixel = 8;		// 256 color

	pcx->xmin = 0;

	pcx->ymin = 0;

	pcx->xmax = LittleShort((short)(width-1));

	pcx->ymax = LittleShort((short)(height-1));

	pcx->hres = LittleShort((short)width);

	pcx->vres = LittleShort((short)height);

	Q_memset (pcx->palette,0,sizeof(pcx->palette));

	pcx->color_planes = 1;		// chunky image

	pcx->bytes_per_line = LittleShort((short)width);

	pcx->palette_type = LittleShort(2);		// not a grey scale

	Q_memset (pcx->filler,0,sizeof(pcx->filler));

// pack the image

	pack = &pcx->data;

	for (i=0 ; i

	{

		for (j=0 ; j

		{

			if ( (*data & 0xc0) != 0xc0)

				*pack++ = *data++;

			else

			{

				*pack++ = 0xc1;

				*pack++ = *data++;

			}

		}

		data += rowbytes - width;

	}

// write the palette

	*pack++ = 0x0c;	// palette ID byte

	for (i=0 ; i<768 ; i++)

		*pack++ = *palette++;

// write output file

	length = pack - (byte *)pcx;

	COM_WriteFile (filename, pcx, length);

}

/*

==================

SCR_ScreenShot_f

==================

*/

void SCR_ScreenShot_f (void)

{

	int     i;

	char		pcxname[80];

	char		checkname[MAX_OSPATH];

//

// find a file name to save it to

//

	strcpy(pcxname,"quake00.pcx");

	for (i=0 ; i<=99 ; i++)

	{

		pcxname[5] = i/10 + '0';

		pcxname[6] = i%10 + '0';

		sprintf (checkname, "%s/%s", com_gamedir, pcxname);

		if (Sys_FileTime(checkname) == -1)

			break;	// file doesn't exist

	}

	if (i==100)

	{

		Con_Printf ("SCR_ScreenShot_f: Couldn't create a PCX file\n");

		return;

 	}

//

// save the pcx file

//

	D_EnableBackBufferAccess ();	// enable direct drawing of console to back

									//  buffer

	WritePCXfile (pcxname, vid.buffer, vid.width, vid.height, vid.rowbytes,

				  host_basepal);

	D_DisableBackBufferAccess ();	// for adapters that can't stay mapped in

									//  for linear writes all the time

	Con_Printf ("Wrote %s\n", pcxname);

}

//=============================================================================

/*

===============

SCR_BeginLoadingPlaque

================

*/

void SCR_BeginLoadingPlaque (void)

{

	S_StopAllSounds (true);

	if (cls.state != ca_connected)

		return;

	if (cls.signon != SIGNONS)

		return;

// redraw with no console and the loading plaque

	Con_ClearNotify ();

	scr_centertime_off = 0;

	scr_con_current = 0;

	scr_drawloading = true;

	scr_fullupdate = 0;

	Sbar_Changed ();

	SCR_UpdateScreen ();

	scr_drawloading = false;

	scr_disabled_for_loading = true;

	scr_disabled_time = realtime;

	scr_fullupdate = 0;

}

/*

===============

SCR_EndLoadingPlaque

================

*/

void SCR_EndLoadingPlaque (void)

{

	scr_disabled_for_loading = false;

	scr_fullupdate = 0;

	Con_ClearNotify ();

}

//=============================================================================

char	*scr_notifystring;

qboolean	scr_drawdialog;

void SCR_DrawNotifyString (void)

{

	char	*start;

	int		l;

	int		j;

	int		x, y;

	start = scr_notifystring;

	y = vid.height*0.35;

	do

	{

	// scan the width of the line

		for (l=0 ; l<40 ; l++)

			if (start[l] == '\n' || !start[l])

				break;

		x = (vid.width - l*8)/2;

		for (j=0 ; j

			Draw_Character (x, y, start[j]);

		y += 8;

		while (*start && *start != '\n')

			start++;

		if (!*start)

			break;

		start++;		// skip the \n

	} while (1);

}

/*

==================

SCR_ModalMessage

Displays a text string in the center of the screen and waits for a Y or N

keypress.

==================

*/

int SCR_ModalMessage (char *text)

{

	if (cls.state == ca_dedicated)

		return true;

	scr_notifystring = text;

// draw a fresh screen

	scr_fullupdate = 0;

	scr_drawdialog = true;

	SCR_UpdateScreen ();

	scr_drawdialog = false;

	S_ClearBuffer ();		// so dma doesn't loop current sound

	do

	{

		key_count = -1;		// wait for a key down and up

		Sys_SendKeyEvents ();

	} while (key_lastpress != 'y' && key_lastpress != 'n' && key_lastpress != K_ESCAPE);

	scr_fullupdate = 0;

	SCR_UpdateScreen ();

	return key_lastpress == 'y';

}

//=============================================================================

/*

===============

SCR_BringDownConsole

Brings the console down and fades the palettes back to normal

================

*/

void SCR_BringDownConsole (void)

{

	int		i;

	scr_centertime_off = 0;

	for (i=0 ; i<20 && scr_conlines != scr_con_current ; i++)

		SCR_UpdateScreen ();

	cl.cshifts[0].percent = 0;		// no area contents palette on next frame

	VID_SetPalette (host_basepal);

}

/*

==================

SCR_UpdateScreen

This is called every frame, and can also be called explicitly to flush

text to the screen.

WARNING: be very careful calling this from elsewhere, because the refresh

needs almost the entire 256k of stack space!

==================

*/

void SCR_UpdateScreen (void)

{

	static float	oldscr_viewsize;

	static float	oldlcd_x;

	vrect_t		vrect;

	if (scr_skipupdate || block_drawing)

		return;

	scr_copytop = 0;

	scr_copyeverything = 0;

	if (scr_disabled_for_loading)

	{

		if (realtime - scr_disabled_time > 60)

		{

			scr_disabled_for_loading = false;

			Con_Printf ("load failed.\n");

		}

		else

			return;

	}

	if (cls.state == ca_dedicated)

		return;				// stdout only

	if (!scr_initialized || !con_initialized)

		return;				// not initialized yet

	if (scr_viewsize.value != oldscr_viewsize)

	{

		oldscr_viewsize = scr_viewsize.value;

		vid.recalc_refdef = 1;

	}

//

// check for vid changes

//

	if (oldfov != scr_fov.value)

	{

		oldfov = scr_fov.value;

		vid.recalc_refdef = true;

	}

	if (oldlcd_x != lcd_x.value)

	{

		oldlcd_x = lcd_x.value;

		vid.recalc_refdef = true;

	}

	if (oldscreensize != scr_viewsize.value)

	{

		oldscreensize = scr_viewsize.value;

		vid.recalc_refdef = true;

	}

	if (vid.recalc_refdef)

	{

	// something changed, so reorder the screen

		SCR_CalcRefdef ();

	}

//

// do 3D refresh drawing, and then update the screen

//

	D_EnableBackBufferAccess ();	// of all overlay stuff if drawing directly

	if (scr_fullupdate++ < vid.numpages)

	{	// clear the entire screen

		scr_copyeverything = 1;

		Draw_TileClear (0,0,vid.width,vid.height);

		Sbar_Changed ();

	}

	pconupdate = NULL;

	SCR_SetUpToDrawConsole ();

	SCR_EraseCenterString ();

	D_DisableBackBufferAccess ();	// for adapters that can't stay mapped in

									//  for linear writes all the time

	VID_LockBuffer ();

	V_RenderView ();

	VID_UnlockBuffer ();

	D_EnableBackBufferAccess ();	// of all overlay stuff if drawing directly

	if (scr_drawdialog)

	{

		Sbar_Draw ();

		Draw_FadeScreen ();

		SCR_DrawNotifyString ();

		scr_copyeverything = true;

	}

	else if (scr_drawloading)

	{

		SCR_DrawLoading ();

		Sbar_Draw ();

	}

	else if (cl.intermission == 1 && key_dest == key_game)

	{

		Sbar_IntermissionOverlay ();

	}

	else if (cl.intermission == 2 && key_dest == key_game)

	{

		Sbar_FinaleOverlay ();

		SCR_CheckDrawCenterString ();

	}

	else if (cl.intermission == 3 && key_dest == key_game)

	{

		SCR_CheckDrawCenterString ();

	}

	else

	{

		SCR_DrawRam ();

		SCR_DrawNet ();

		SCR_DrawTurtle ();

		SCR_DrawPause ();

		SCR_CheckDrawCenterString ();

		Sbar_Draw ();

		SCR_DrawConsole ();

		M_Draw ();

	}

	D_DisableBackBufferAccess ();	// for adapters that can't stay mapped in

									//  for linear writes all the time

	if (pconupdate)

	{

		D_UpdateRects (pconupdate);

	}

	V_UpdatePalette ();

//

// update one of three areas

//

	if (scr_copyeverything)

	{

		vrect.x = 0;

		vrect.y = 0;

		vrect.width = vid.width;

		vrect.height = vid.height;

		vrect.pnext = 0;

		VID_Update (&vrect);

	}

	else if (scr_copytop)

	{

		vrect.x = 0;

		vrect.y = 0;

		vrect.width = vid.width;

		vrect.height = vid.height - sb_lines;

		vrect.pnext = 0;

		VID_Update (&vrect);

	}

	else

	{

		vrect.x = scr_vrect.x;

		vrect.y = scr_vrect.y;

		vrect.width = scr_vrect.width;

		vrect.height = scr_vrect.height;

		vrect.pnext = 0;

		VID_Update (&vrect);

	}

}

/*

==================

SCR_UpdateWholeScreen

==================

*/

void SCR_UpdateWholeScreen (void)

{

	scr_fullupdate = 0;

	SCR_UpdateScreen ();

}