quakeforge/nq/source/screen.c

1068 lines
21 KiB
C
Raw Normal View History

/*
screen.c
@description@
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:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
$Id$
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <time.h>
#include "r_local.h"
#include "QF/cmd.h"
#include "screen.h"
#include "sbar.h"
#include "input.h"
#include "view.h"
#include "host.h"
#include "QF/sys.h"
#include "QF/console.h"
#include "QF/qendian.h"
#include "QF/keys.h"
#include "draw.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
int oldscreensize;
float oldfov;
int oldsbar;
cvar_t *scr_viewsize;
cvar_t *scr_fov;
cvar_t *scr_conspeed;
cvar_t *scr_centertime;
cvar_t *scr_showram;
cvar_t *scr_showturtle;
cvar_t *scr_showpause;
cvar_t *scr_printspeed;
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);
void
SCR_InitCvars (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 < l; j++, x += 8) {
Draw_Character8 (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;
int 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->int_val < 30)
Cvar_Set (scr_viewsize, "30");
if (scr_viewsize->int_val > 120)
Cvar_Set (scr_viewsize, "120");
// bound field of view
if (scr_fov->value < 10)
Cvar_Set (scr_fov, "10");
if (scr_fov->value > 170)
Cvar_Set (scr_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->int_val;
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 (scr_viewsize, scr_viewsize->int_val + 10);
vid.recalc_refdef = 1;
}
/*
=================
SCR_SizeDown_f
Keybinding command
=================
*/
void
SCR_SizeDown_f (void)
{
Cvar_SetValue (scr_viewsize, scr_viewsize->int_val - 10);
vid.recalc_refdef = 1;
}
//============================================================================
/*
==================
SCR_Init
==================
*/
void
SCR_Init (void)
{
scr_fov = Cvar_Get ("fov", "90", CVAR_NONE, "10 - 170");
scr_viewsize = Cvar_Get ("viewsize", "100", CVAR_ARCHIVE, "None");
scr_conspeed = Cvar_Get ("scr_conspeed", "300", CVAR_NONE, "None");
scr_showram = Cvar_Get ("showram", "1", CVAR_NONE, "None");
scr_showturtle = Cvar_Get ("showturtle", "0", CVAR_NONE, "None");
scr_showpause = Cvar_Get ("showpause", "1", CVAR_NONE, "None");
scr_centertime = Cvar_Get ("scr_centertime", "2", CVAR_NONE, "None");
scr_printspeed = Cvar_Get ("scr_printspeed", "8", CVAR_NONE, "None");
//
// register our commands
//
Cmd_AddCommand ("screenshot", SCR_ScreenShot_f, "No Description");
Cmd_AddCommand ("sizeup", SCR_SizeUp_f, "No Description");
Cmd_AddCommand ("sizedown", SCR_SizeDown_f, "No Description");
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->int_val)
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->int_val)
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);
}
void
SCR_DrawFPS (void)
{
extern cvar_t *show_fps;
static double lastframetime;
double t;
extern int fps_count;
static int lastfps;
int x, y;
char st[80];
if (!show_fps->int_val)
return;
t = Sys_DoubleTime ();
if ((t - lastframetime) >= 1.0) {
lastfps = fps_count;
fps_count = 0;
lastframetime = t;
}
snprintf (st, sizeof (st), "%-3d FPS", lastfps);
/* Misty: New trick! (for me) the ? makes this work like a if then else -
IE: if cl_hudswap->int_val is not null, do first case, else (else is a
: here) do second case. Deek taught me this trick */
x = cl_hudswap->int_val ? vid.width - ((strlen (st) * 8) + 8) : 8;
y = vid.height - sb_lines - 8;
Draw_String8 (x, y, st);
}
/* Misty: I like to see the time */
void
SCR_DrawTime (void)
{
extern cvar_t *show_time;
int x, y;
char st[80];
char local_time[120];
time_t systime;
/* any cvar that can take multiple settings must be able to handle abuse.
*/
if (show_time->int_val <= 0)
return;
/* actually find the time and set systime to it */
time (&systime);
if (show_time->int_val == 1) {
/* now set local_time to 24 hour time using hours:minutes format */
strftime (local_time, sizeof (local_time), "%k:%M",
localtime (&systime));
} else if (show_time->int_val >= 2) {
/* >= is another cvar abuse protector */
strftime (local_time, sizeof (local_time), "%l:%M %P",
localtime (&systime));
}
/* now actually print it to the screen directly above where show_fps is */
snprintf (st, sizeof (st), "%s", local_time);
x = cl_hudswap->int_val ? vid.width - ((strlen (st) * 8) + 8) : 8;
y = vid.height - sb_lines - 16;
Draw_String8 (x, y, st);
}
/*
==============
DrawPause
==============
*/
void
SCR_DrawPause (void)
{
qpic_t *pic;
if (!scr_showpause->int_val) // 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
if (!cl.worldmodel || cls.signon != SIGNONS) {
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);
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];
//
// find a file name to save it to
//
strcpy (pcxname, "nuq000.pcx");
for (i = 0; i <= 999; i++) {
pcxname[3] = i / 100 + '0';
pcxname[4] = i / 10 % 10 + '0';
pcxname[5] = i % 10 + '0';
snprintf (checkname, sizeof (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 < l; j++, x += 8)
Draw_Character8 (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
IN_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 int oldscr_viewsize;
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->int_val != oldscr_viewsize) {
oldscr_viewsize = scr_viewsize->int_val;
vid.recalc_refdef = 1;
}
//
// check for vid changes
//
if (oldfov != scr_fov->value) {
oldfov = scr_fov->value;
vid.recalc_refdef = true;
}
if (oldscreensize != scr_viewsize->int_val) {
oldscreensize = scr_viewsize->int_val;
vid.recalc_refdef = true;
}
if (oldsbar != cl_sbar->int_val) {
oldsbar = cl_sbar->int_val;
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_DrawFPS ();
SCR_DrawTime ();
SCR_CheckDrawCenterString ();
Sbar_Draw ();
SCR_DrawConsole ();
// FIXME: MENUCODE
// 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 ();
}