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

/*

* $Header: /H2 Mission Pack/Screen.c 19 3/18/98 11:34p Jmonroe $

*/

#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","4"};

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 scr_topupdate;

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;

int total_loading_size, current_loading_size, loading_stage;

static qboolean scr_needfull = false;

void SCR_ScreenShot_f (void);

void Plaque_Draw (char *message, qboolean AlwaysDraw);

void Info_Plaque_Draw (char *message);

void Bottom_Plaque_Draw (char *message);

/*

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

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;

static int lines;

#define MAXLINES 27

static int StartC[MAXLINES],EndC[MAXLINES];

#define MAX_INFO 1024

char infomessage[MAX_INFO];

qboolean info_up = false;

extern int *pr_info_string_index;

extern char *pr_global_info_strings;

extern int pr_info_string_count;

float introTime = 0.0;

void UpdateInfoMessage(void)

{

unsigned int i;

unsigned int check;

char *newmessage;

strcpy(infomessage, "Objectives:");

if (!pr_global_info_strings)

return;

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

{

check = (1 << i);

if (cl.info_mask & check)

{

newmessage = &pr_global_info_strings[pr_info_string_index[i]];

strcat(infomessage, "@@");

strcat(infomessage, newmessage);

}

}

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

{

check = (1 << i);

if (cl.info_mask2 & check)

{

newmessage = &pr_global_info_strings[pr_info_string_index[i+32]];

strcat(infomessage, "@@");

strcat(infomessage, newmessage);

}

}

}

void FindTextBreaks(char *message, int Width)

{

int length,pos,start,lastspace,oldlast;

length = strlen(message);

lines = pos = start = 0;

lastspace = -1;

while(1)

{

if (pos-start >= Width || message[pos] == '@' ||

message[pos] == 0)

{

oldlast = lastspace;

if (message[pos] == '@' || lastspace == -1 || message[pos] == 0)

lastspace = pos;

StartC[lines] = start;

EndC[lines] = lastspace;

lines++;

if (lines == MAXLINES)

return;

if (message[pos] == '@')

start = pos + 1;

else if (oldlast == -1)

start = lastspace;

else

start = lastspace + 1;

lastspace = -1;

}

if (message[pos] == 32) lastspace = pos;

else if (message[pos] == 0)

{

break;

}

pos++;

}

}

/*

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

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;

FindTextBreaks(scr_centerstring, 38);

scr_center_lines = lines;

}

/*

void SCR_EraseCenterString (void)

{

int y;

if (scr_erase_center++ > vid.numpages)

{

scr_erase_lines = 0;

return;

}

y = ((25-lines) * 8) / 2;

scr_copytop = 1;

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

}

*/

void SCR_DrawCenterString (void)

{

int i;

int bx, by;

int remaining;

char temp[80];

// 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;

FindTextBreaks(scr_centerstring, 38);

by = ((25-lines) * 8) / 2;

for(i=0;i<lines;i++,by+=8)

{

strncpy(temp,&scr_centerstring[StartC[i]],EndC[i]-StartC[i]);

temp[EndC[i]-StartC[i]] = 0;

bx = ((40-strlen(temp)) * 8) / 2;

M_Print2 (bx, by, temp);

}

}

qboolean SCR_CheckDrawCenterString2 (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 false;

if (key_dest != key_game)

return false;

return true;

}

void SCR_CheckDrawCenterString (void)

{

if (SCR_CheckDrawCenterString2())

if(intro_playing)

Bottom_Plaque_Draw(scr_centerstring);

else

SCR_DrawCenterString ();

}

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

/*

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

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

SB_Changed();

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

// bound viewsize

if (scr_viewsize.value < 30)

Cvar_Set ("viewsize","30");

if (scr_viewsize.value > 110)

Cvar_Set ("viewsize","110");

// bound field of view

if (scr_fov.value < 10)

Cvar_Set ("fov","10");

if (scr_fov.value > 110)

Cvar_Set ("fov","110");

// intermission is always full screen

if (cl.intermission)

size = 110;

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;

*/

if(size >= 110)

{ // No status bar

sb_lines = 0;

}

else

{

sb_lines = 46;

}

// 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);

SB_ViewSizeChanged();

vid.recalc_refdef = 1;

}

/*

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

SCR_SizeDown_f

Keybinding command

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

*/

void SCR_SizeDown_f (void)

{

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

SB_ViewSizeChanged();

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.05)

{

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;

float delta;

static qboolean newdraw = false;

int finaly;

static float LogoPercent,LogoTargetPercent;

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

return;

if (!cl.paused)

{

newdraw = false;

return;

}

if (!newdraw)

{

newdraw = true;

LogoTargetPercent= 1;

LogoPercent = 0;

}

pic = Draw_CachePic ("gfx/menu/paused.lmp");

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

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

if (LogoPercent < LogoTargetPercent)

{

delta = ((LogoTargetPercent-LogoPercent)/.5)*host_frametime;

if (delta < 0.004)

{

delta = 0.004;

}

LogoPercent += delta;

if (LogoPercent > LogoTargetPercent)

{

LogoPercent = LogoTargetPercent;

}

}

finaly = ((float)pic->height * LogoPercent) - pic->height;

Draw_TransPicCropped ( (vid.width - pic->width)/2, finaly, pic);

}

/*

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

SCR_DrawLoading

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

*/

void SCR_DrawLoading (void)

{

int size, count, offset;

qpic_t *pic;

if (!scr_drawloading && loading_stage == 0)

return;

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

offset = (vid.width - pic->width)/2;

Draw_TransPic (offset , 0, pic);

if (loading_stage == 0)

return;

if (total_loading_size)

size = current_loading_size * 106 / total_loading_size;

else

size = 0;

if (loading_stage == 1)

count = size;

else

count = 106;

Draw_Fill (offset+42, 87, count, 1, 136);

Draw_Fill (offset+42, 87+1, count, 4, 138);

Draw_Fill (offset+42, 87+5, count, 1, 136);

if (loading_stage == 2)

count = size;

else

count = 0;

Draw_Fill (offset+42, 97, count, 1, 168);

Draw_Fill (offset+42, 97+1, count, 4, 170);

Draw_Fill (offset+42, 97+5, count, 1, 168);

}

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

/*

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

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);

SB_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);

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

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

// pack the image

pack = &pcx->data;

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

{

for (j=0 ; j<width ; 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];

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

Sys_mkdir (checkname);

//

// find a file name to save it to

//

strcpy(pcxname,"shots/hexen00.pcx");

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

{

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

pcxname[12] = 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;

SB_Changed();

SCR_UpdateScreen ();

scr_drawloading = false;

scr_disabled_for_loading = true;

scr_disabled_time = realtime;

}

/*

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

SCR_EndLoadingPlaque

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

*/

void SCR_EndLoadingPlaque (void)

{

scr_disabled_for_loading = false;

scr_fullupdate = 0;

scr_topupdate = 0;

Con_ClearNotify ();

}

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

char *scr_notifystring;

qboolean scr_drawdialog;

void SCR_DrawNotifyString (void)

{

Plaque_Draw(scr_notifystring,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)

return;

scr_copytop = 0;

scr_copyeverything = 0;

if (scr_disabled_for_loading)

{

if (realtime - scr_disabled_time > 60)

{

scr_disabled_for_loading = false;

total_loading_size = 0;

loading_stage = 0;

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_needfull && (!plaquemessage || plaquemessage[0] == 0 || !SCR_CheckDrawCenterString2()))

scr_fullupdate = 0;

if (scr_fullupdate++ < vid.numpages)

{ // clear the entire screen

scr_copyeverything = 1;

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

SB_Changed();

}

else if (scr_topupdate++ < vid.numpages)

{

scr_copyeverything = 1;

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

SB_Changed();

}

pconupdate = NULL;

SCR_SetUpToDrawConsole ();

//SCR_EraseCenterString ();

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

// for linear writes all the time

if (cl.intermission < 1 || cl.intermission > 12)

{

VID_LockBuffer ();

V_RenderView ();

VID_UnlockBuffer ();

}

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

if (scr_drawdialog)

{

SB_Draw();

Draw_FadeScreen ();

SCR_DrawNotifyString ();