libretro/quake2-for-ps2
1
0 Fork 0
mirror of https://github.com/libretro/quake2-for-ps2.git synced 2026-11-07 04:25:58 -10:00
Code Issues Packages Projects Releases Wiki Activity
Files
ce8cc0721ca9324acf8678f430a6fe53773aa637
quake2-for-ps2/src/client/cl_scrn.c
T
Guilherme Lampert ce8cc0721c Finished texture image loading and got the menus working. 
- Finished texture image loading for PCX, WAL and TGA;
- Added the NET driver for the PS2, loopback only for local
single-player;
- Replaced all malloc/free calls with either Quake’s Z_Malloc or
PS2_MemAlloc, so we can keep precise memory usage statistics;
- Several other miscellaneous changes.
2015-10-29 03:21:15 -02:00

1407 lines
32 KiB
C
Raw Blame History

/*
Copyright (C) 1997-2001 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.
*/
// cl_scrn.c -- master for refresh, status bar, console, chat, notify, etc
/*
full screen console
put up loading plaque
blanked background with loading plaque
blanked background with menu
cinematics
full screen image for quit and victory
end of unit intermissions
*/
#include "client.h"
float scr_con_current; // aproaches scr_conlines at scr_conspeed
float scr_conlines; // 0.0 to 1.0 lines of console to display
qboolean scr_initialized; // ready to draw
int scr_draw_loading;
vrect_t scr_vrect; // position of render window on screen
cvar_t * scr_viewsize;
cvar_t * scr_conspeed;
cvar_t * scr_centertime;
cvar_t * scr_showturtle;
cvar_t * scr_showpause;
cvar_t * scr_printspeed;
cvar_t * scr_netgraph;
cvar_t * scr_timegraph;
cvar_t * scr_debuggraph;
cvar_t * scr_graphheight;
cvar_t * scr_graphscale;
cvar_t * scr_graphshift;
cvar_t * scr_drawall;
typedef struct
{
int x1, y1, x2, y2;
} dirty_t;
dirty_t scr_dirty, scr_old_dirty[2];
char crosshair_pic[MAX_QPATH];
int crosshair_width, crosshair_height;
void SCR_TimeRefresh_f(void);
void SCR_Loading_f(void);
/*
===============================================================================
BAR GRAPHS
===============================================================================
*/
/*
==============
CL_AddNetgraph
A new packet was just parsed
==============
*/
void CL_AddNetgraph(void)
{
int i;
int in;
int ping;
// if using the debuggraph for something else, don't
// add the net lines
if (scr_debuggraph->value || scr_timegraph->value)
return;
for (i = 0; i < cls.netchan.dropped; i++)
SCR_DebugGraph(30, 0x40);
for (i = 0; i < cl.surpressCount; i++)
SCR_DebugGraph(30, 0xdf);
// see what the latency was on this packet
in = cls.netchan.incoming_acknowledged & (CMD_BACKUP - 1);
ping = cls.realtime - cl.cmd_time[in];
ping /= 30;
if (ping > 30)
ping = 30;
SCR_DebugGraph(ping, 0xd0);
}
typedef struct
{
float value;
int color;
} graphsamp_t;
static int current;
static graphsamp_t values[1024];
/*
==============
SCR_DebugGraph
==============
*/
void SCR_DebugGraph(float value, int color)
{
values[current & 1023].value = value;
values[current & 1023].color = color;
current++;
}
/*
==============
SCR_DrawDebugGraph
==============
*/
void SCR_DrawDebugGraph(void)
{
int a, x, y, w, i, h;
float v;
int color;
//
// draw the graph
//
w = scr_vrect.width;
x = scr_vrect.x;
y = scr_vrect.y + scr_vrect.height;
re.DrawFill(x, y - scr_graphheight->value, w, scr_graphheight->value, 8);
for (a = 0; a < w; a++)
{
i = (current - 1 - a + 1024) & 1023;
v = values[i].value;
color = values[i].color;
v = v * scr_graphscale->value + scr_graphshift->value;
if (v < 0)
{
v += scr_graphheight->value * (1 + (int)(-v / scr_graphheight->value));
}
h = (int)v % (int)scr_graphheight->value;
re.DrawFill(x + w - 1 - a, y - h, 1, h, color);
}
}
/*
===============================================================================
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_center;
/*
==============
SCR_CenterPrint
Called for important messages that should stay in the center of the screen
for a few moments
==============
*/
void SCR_CenterPrint(const char * str)
{
const char * s;
char line[64];
int i, j, l;
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;
s = str;
while (*s)
{
if (*s == '\n')
scr_center_lines++;
s++;
}
// echo it to the console
Com_Printf("\n\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n\n");
s = str;
do
{
// scan the width of the line
for (l = 0; l < 40; l++)
if (s[l] == '\n' || !s[l])
break;
for (i = 0; i < (40 - l) / 2; i++)
line[i] = ' ';
for (j = 0; j < l; j++)
{
line[i++] = s[j];
}
line[i] = '\n';
line[i + 1] = 0;
Com_Printf("%s", line);
while (*s && *s != '\n')
s++;
if (!*s)
break;
s++; // skip the \n
} while (1);
Com_Printf("\n\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n\n");
Con_ClearNotify();
}
void SCR_DrawCenterString(void)
{
char * start;
int l;
int j;
int x, y;
int remaining;
// the finale prints the characters one at a time
remaining = 9999;
scr_erase_center = 0;
start = scr_centerstring;
if (scr_center_lines <= 4)
y = viddef.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 = (viddef.width - l * 8) / 2;
SCR_AddDirtyPoint(x, y);
for (j = 0; j < l; j++, x += 8)
{
re.DrawChar(x, y, start[j]);
if (!remaining--)
return;
}
SCR_AddDirtyPoint(x, y + 8);
y += 8;
while (*start && *start != '\n')
start++;
if (!*start)
break;
start++; // skip the \n
} while (1);
}
void SCR_CheckDrawCenterString(void)
{
scr_centertime_off -= cls.frametime;
if (scr_centertime_off <= 0)
return;
SCR_DrawCenterString();
}
//=============================================================================
/*
=================
SCR_CalcVrect
Sets scr_vrect, the coordinates of the rendered window
=================
*/
static void SCR_CalcVrect(void)
{
int size;
// bound viewsize
if (scr_viewsize->value < 40)
Cvar_Set("viewsize", "40");
if (scr_viewsize->value > 100)
Cvar_Set("viewsize", "100");
size = scr_viewsize->value;
scr_vrect.width = viddef.width * size / 100;
scr_vrect.width &= ~7;
scr_vrect.height = viddef.height * size / 100;
scr_vrect.height &= ~1;
scr_vrect.x = (viddef.width - scr_vrect.width) / 2;
scr_vrect.y = (viddef.height - scr_vrect.height) / 2;
}
/*
=================
SCR_SizeUp_f
Keybinding command
=================
*/
void SCR_SizeUp_f(void)
{
Cvar_SetValue("viewsize", scr_viewsize->value + 10);
}
/*
=================
SCR_SizeDown_f
Keybinding command
=================
*/
void SCR_SizeDown_f(void)
{
Cvar_SetValue("viewsize", scr_viewsize->value - 10);
}
/*
=================
SCR_Sky_f
Set a specific sky and rotation speed
=================
*/
void SCR_Sky_f(void)
{
float rotate;
vec3_t axis;
if (Cmd_Argc() < 2)
{
Com_Printf("Usage: sky <basename> <rotate> <axis x y z>\n");
return;
}
if (Cmd_Argc() > 2)
rotate = atof(Cmd_Argv(2));
else
rotate = 0;
if (Cmd_Argc() == 6)
{
axis[0] = atof(Cmd_Argv(3));
axis[1] = atof(Cmd_Argv(4));
axis[2] = atof(Cmd_Argv(5));
}
else
{
axis[0] = 0;
axis[1] = 0;
axis[2] = 1;
}
re.SetSky(Cmd_Argv(1), rotate, axis);
}
//============================================================================
/*
==================
SCR_Init
==================
*/
void SCR_Init(void)
{
scr_viewsize = Cvar_Get("viewsize", "100", CVAR_ARCHIVE);
scr_conspeed = Cvar_Get("scr_conspeed", "3", 0);
scr_showturtle = Cvar_Get("scr_showturtle", "0", 0);
scr_showpause = Cvar_Get("scr_showpause", "1", 0);
scr_centertime = Cvar_Get("scr_centertime", "2.5", 0);
scr_printspeed = Cvar_Get("scr_printspeed", "8", 0);
scr_netgraph = Cvar_Get("netgraph", "0", 0);
scr_timegraph = Cvar_Get("timegraph", "0", 0);
scr_debuggraph = Cvar_Get("debuggraph", "0", 0);
scr_graphheight = Cvar_Get("graphheight", "32", 0);
scr_graphscale = Cvar_Get("graphscale", "1", 0);
scr_graphshift = Cvar_Get("graphshift", "0", 0);
scr_drawall = Cvar_Get("scr_drawall", "0", 0);
//
// register our commands
//
Cmd_AddCommand("timerefresh", SCR_TimeRefresh_f);
Cmd_AddCommand("loading", SCR_Loading_f);
Cmd_AddCommand("sizeup", SCR_SizeUp_f);
Cmd_AddCommand("sizedown", SCR_SizeDown_f);
Cmd_AddCommand("sky", SCR_Sky_f);
scr_initialized = true;
}
/*
==============
SCR_DrawNet
==============
*/
void SCR_DrawNet(void)
{
if (cls.netchan.outgoing_sequence - cls.netchan.incoming_acknowledged < CMD_BACKUP - 1)
{
return;
}
re.DrawPic(scr_vrect.x + 64, scr_vrect.y, "net");
}
/*
==============
SCR_DrawPause
==============
*/
void SCR_DrawPause(void)
{
int w, h;
if (!scr_showpause->value) // turn off for screenshots
return;
if (!cl_paused->value)
return;
re.DrawGetPicSize(&w, &h, "pause");
re.DrawPic((viddef.width - w) / 2, viddef.height / 2 + 8, "pause");
}
/*
==============
SCR_DrawLoading
==============
*/
void SCR_DrawLoading(void)
{
int w, h;
if (!scr_draw_loading)
return;
scr_draw_loading = false;
re.DrawGetPicSize(&w, &h, "loading");
re.DrawPic((viddef.width - w) / 2, (viddef.height - h) / 2, "loading");
}
//=============================================================================
/*
==================
SCR_RunConsole
Scroll it up or down
==================
*/
void SCR_RunConsole(void)
{
// decide on the height of the console
if (cls.key_dest == key_console)
scr_conlines = 0.5; // half screen
else
scr_conlines = 0; // none visible
if (scr_conlines < scr_con_current)
{
scr_con_current -= scr_conspeed->value * cls.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 * cls.frametime;
if (scr_conlines < scr_con_current)
scr_con_current = scr_conlines;
}
}
/*
==================
SCR_DrawConsole
==================
*/
void SCR_DrawConsole(void)
{
Con_CheckResize();
if (cls.state == ca_disconnected || cls.state == ca_connecting)
{ // forced full screen console
Con_DrawConsole(1.0);
return;
}
if (cls.state != ca_active || !cl.refresh_prepped)
{ // connected, but can't render
Con_DrawConsole(0.5);
re.DrawFill(0, viddef.height / 2, viddef.width, viddef.height / 2, 0);
return;
}
if (scr_con_current)
{
Con_DrawConsole(scr_con_current);
}
else
{
if (cls.key_dest == key_game || cls.key_dest == key_message)
{
Con_DrawNotify(); // only draw notify in game
}
}
}
//=============================================================================
/*
================
SCR_BeginLoadingPlaque
================
*/
void SCR_BeginLoadingPlaque(void)
{
Com_DPrintf("*** SCR_BeginLoadingPlaque ***\n");
S_StopAllSounds();
cl.sound_prepped = false; // don't play ambients
CDAudio_Stop();
if (cls.disable_screen)
return;
if (developer->value)
return;
if (cls.state == ca_disconnected)
return; // if at console, don't bring up the plaque
if (cls.key_dest == key_console)
return;
if (cl.cinematictime > 0)
scr_draw_loading = 2; // clear to black first
else
scr_draw_loading = 1;
SCR_UpdateScreen();
cls.disable_screen = Sys_Milliseconds();
cls.disable_servercount = cl.servercount;
}
/*
================
SCR_EndLoadingPlaque
================
*/
void SCR_EndLoadingPlaque(void)
{
Com_DPrintf("*** SCR_EndLoadingPlaque ***\n");
cls.disable_screen = 0;
Con_ClearNotify();
}
/*
================
SCR_Loading_f
================
*/
void SCR_Loading_f(void)
{
SCR_BeginLoadingPlaque();
}
/*
================
SCR_TimeRefresh_f
================
*/
int entitycmpfnc(const entity_t * a, const entity_t * b)
{
/*
** all other models are sorted by model then skin
*/
if (a->model == b->model)
{
return ((int)a->skin - (int)b->skin);
}
else
{
return ((int)a->model - (int)b->model);
}
}
void SCR_TimeRefresh_f(void)
{
int i;
int start, stop;
float time;
if (cls.state != ca_active)
return;
start = Sys_Milliseconds();
if (Cmd_Argc() == 2)
{
// run without page flipping
re.BeginFrame(0);
for (i = 0; i < 128; i++)
{
cl.refdef.viewangles[1] = i / 128.0 * 360.0;
re.RenderFrame(&cl.refdef);
}
re.EndFrame();
}
else
{
for (i = 0; i < 128; i++)
{
cl.refdef.viewangles[1] = i / 128.0 * 360.0;
re.BeginFrame(0);
re.RenderFrame(&cl.refdef);
re.EndFrame();
}
}
stop = Sys_Milliseconds();
time = (stop - start) / 1000.0;
Com_Printf("%f seconds (%f fps)\n", time, 128 / time);
}
/*
=================
SCR_AddDirtyPoint
=================
*/
void SCR_AddDirtyPoint(int x, int y)
{
if (x < scr_dirty.x1)
scr_dirty.x1 = x;
if (x > scr_dirty.x2)
scr_dirty.x2 = x;
if (y < scr_dirty.y1)
scr_dirty.y1 = y;
if (y > scr_dirty.y2)
scr_dirty.y2 = y;
}
void SCR_DirtyScreen(void)
{
SCR_AddDirtyPoint(0, 0);
SCR_AddDirtyPoint(viddef.width - 1, viddef.height - 1);
}
/*
==============
SCR_TileClear
Clear any parts of the tiled background that were drawn on last frame
==============
*/
void SCR_TileClear(void)
{
int i;
int top, bottom, left, right;
dirty_t clear;
if (scr_drawall->value)
SCR_DirtyScreen(); // for power vr or broken page flippers...
if (scr_con_current == 1.0)
return; // full screen console
if (scr_viewsize->value == 100)
return; // full screen rendering
if (cl.cinematictime > 0)
return; // full screen cinematic
// erase rect will be the union of the past three frames
// so tripple buffering works properly
clear = scr_dirty;
for (i = 0; i < 2; i++)
{
if (scr_old_dirty[i].x1 < clear.x1)
clear.x1 = scr_old_dirty[i].x1;
if (scr_old_dirty[i].x2 > clear.x2)
clear.x2 = scr_old_dirty[i].x2;
if (scr_old_dirty[i].y1 < clear.y1)
clear.y1 = scr_old_dirty[i].y1;
if (scr_old_dirty[i].y2 > clear.y2)
clear.y2 = scr_old_dirty[i].y2;
}
scr_old_dirty[1] = scr_old_dirty[0];
scr_old_dirty[0] = scr_dirty;
scr_dirty.x1 = 9999;
scr_dirty.x2 = -9999;
scr_dirty.y1 = 9999;
scr_dirty.y2 = -9999;
// don't bother with anything convered by the console)
top = scr_con_current * viddef.height;
if (top >= clear.y1)
clear.y1 = top;
if (clear.y2 <= clear.y1)
return; // nothing disturbed
top = scr_vrect.y;
bottom = top + scr_vrect.height - 1;
left = scr_vrect.x;
right = left + scr_vrect.width - 1;
if (clear.y1 < top)
{ // clear above view screen
i = clear.y2 < top - 1 ? clear.y2 : top - 1;
re.DrawTileClear(clear.x1, clear.y1,
clear.x2 - clear.x1 + 1, i - clear.y1 + 1, "backtile");
clear.y1 = top;
}
if (clear.y2 > bottom)
{ // clear below view screen
i = clear.y1 > bottom + 1 ? clear.y1 : bottom + 1;
re.DrawTileClear(clear.x1, i,
clear.x2 - clear.x1 + 1, clear.y2 - i + 1, "backtile");
clear.y2 = bottom;
}
if (clear.x1 < left)
{ // clear left of view screen
i = clear.x2 < left - 1 ? clear.x2 : left - 1;
re.DrawTileClear(clear.x1, clear.y1,
i - clear.x1 + 1, clear.y2 - clear.y1 + 1, "backtile");
clear.x1 = left;
}
if (clear.x2 > right)
{ // clear left of view screen
i = clear.x1 > right + 1 ? clear.x1 : right + 1;
re.DrawTileClear(i, clear.y1,
clear.x2 - i + 1, clear.y2 - clear.y1 + 1, "backtile");
clear.x2 = right;
}
}
//===============================================================
#define STAT_MINUS 10 // num frame for '-' stats digit
char * sb_nums[2][11] =
{
{ "num_0", "num_1", "num_2", "num_3", "num_4", "num_5",
"num_6", "num_7", "num_8", "num_9", "num_minus" },
{ "anum_0", "anum_1", "anum_2", "anum_3", "anum_4", "anum_5",
"anum_6", "anum_7", "anum_8", "anum_9", "anum_minus" }
};
#define ICON_WIDTH 24
#define ICON_HEIGHT 24
#define CHAR_WIDTH 16
#define ICON_SPACE 8
/*
================
SizeHUDString
Allow embedded \n in the string
================
*/
void SizeHUDString(char * string, int * w, int * h)
{
int lines, width, current;
lines = 1;
width = 0;
current = 0;
while (*string)
{
if (*string == '\n')
{
lines++;
current = 0;
}
else
{
current++;
if (current > width)
width = current;
}
string++;
}
*w = width * 8;
*h = lines * 8;
}
void DrawHUDString(char * string, int x, int y, int centerwidth, int xor )
{
int margin;
char line[1024];
int width;
int i;
margin = x;
while (*string)
{
// scan out one line of text from the string
width = 0;
while (*string && *string != '\n')
line[width++] = *string++;
line[width] = 0;
if (centerwidth)
x = margin + (centerwidth - width * 8) / 2;
else
x = margin;
for (i = 0; i < width; i++)
{
re.DrawChar(x, y, line[i] ^ xor);
x += 8;
}
if (*string)
{
string++; // skip the \n
x = margin;
y += 8;
}
}
}
/*
==============
SCR_DrawField
==============
*/
void SCR_DrawField(int x, int y, int color, int width, int value)
{
char num[16], *ptr;
int l;
int frame;
if (width < 1)
return;
// draw number string
if (width > 5)
width = 5;
SCR_AddDirtyPoint(x, y);
SCR_AddDirtyPoint(x + width * CHAR_WIDTH + 2, y + 23);
Com_sprintf(num, sizeof(num), "%i", value);
l = strlen(num);
if (l > width)
l = width;
x += 2 + CHAR_WIDTH * (width - l);
ptr = num;
while (*ptr && l)
{
if (*ptr == '-')
frame = STAT_MINUS;
else
frame = *ptr - '0';
re.DrawPic(x, y, sb_nums[color][frame]);
x += CHAR_WIDTH;
ptr++;
l--;
}
}
/*
===============
SCR_TouchPics
Allows rendering code to cache all needed sbar graphics
===============
*/
void SCR_TouchPics(void)
{
int i, j;
for (i = 0; i < 2; i++)
{
for (j = 0; j < 11; j++)
{
re.RegisterPic(sb_nums[i][j]);
}
}
if (crosshair->value)
{
if (crosshair->value > 3 || crosshair->value < 0)
{
crosshair->value = 3;
}
Com_sprintf(crosshair_pic, sizeof(crosshair_pic), "ch%i", (int)(crosshair->value));
re.DrawGetPicSize(&crosshair_width, &crosshair_height, crosshair_pic);
if (!crosshair_width)
{
crosshair_pic[0] = 0;
}
}
}
/*
================
SCR_ExecuteLayoutString
================
*/
void SCR_ExecuteLayoutString(char * s)
{
int x, y;
int value;
char * token;
int width;
int index;
clientinfo_t * ci;
if (cls.state != ca_active || !cl.refresh_prepped)
return;
if (!s[0])
return;
x = 0;
y = 0;
width = 3;
while (s)
{
token = COM_Parse(&s);
if (!strcmp(token, "xl"))
{
token = COM_Parse(&s);
x = atoi(token);
continue;
}
if (!strcmp(token, "xr"))
{
token = COM_Parse(&s);
x = viddef.width + atoi(token);
continue;
}
if (!strcmp(token, "xv"))
{
token = COM_Parse(&s);
x = viddef.width / 2 - 160 + atoi(token);
continue;
}
if (!strcmp(token, "yt"))
{
token = COM_Parse(&s);
y = atoi(token);
continue;
}
if (!strcmp(token, "yb"))
{
token = COM_Parse(&s);
y = viddef.height + atoi(token);
continue;
}
if (!strcmp(token, "yv"))
{
token = COM_Parse(&s);
y = viddef.height / 2 - 120 + atoi(token);
continue;
}
if (!strcmp(token, "pic"))
{ // draw a pic from a stat number
token = COM_Parse(&s);
value = cl.frame.playerstate.stats[atoi(token)];
if (value >= MAX_IMAGES)
Com_Error(ERR_DROP, "Pic >= MAX_IMAGES");
if (cl.configstrings[CS_IMAGES + value])
{
SCR_AddDirtyPoint(x, y);
SCR_AddDirtyPoint(x + 23, y + 23);
re.DrawPic(x, y, cl.configstrings[CS_IMAGES + value]);
}
continue;
}
if (!strcmp(token, "client"))
{ // draw a deathmatch client block
int score, ping, time;
token = COM_Parse(&s);
x = viddef.width / 2 - 160 + atoi(token);
token = COM_Parse(&s);
y = viddef.height / 2 - 120 + atoi(token);
SCR_AddDirtyPoint(x, y);
SCR_AddDirtyPoint(x + 159, y + 31);
token = COM_Parse(&s);
value = atoi(token);
if (value >= MAX_CLIENTS || value < 0)
Com_Error(ERR_DROP, "client >= MAX_CLIENTS");
ci = &cl.clientinfo[value];
token = COM_Parse(&s);
score = atoi(token);
token = COM_Parse(&s);
ping = atoi(token);
token = COM_Parse(&s);
time = atoi(token);
DrawAltString(x + 32, y, ci->name);
DrawString(x + 32, y + 8, "Score: ");
DrawAltString(x + 32 + 7 * 8, y + 8, va("%i", score));
DrawString(x + 32, y + 16, va("Ping: %i", ping));
DrawString(x + 32, y + 24, va("Time: %i", time));
if (!ci->icon)
ci = &cl.baseclientinfo;
re.DrawPic(x, y, ci->iconname);
continue;
}
if (!strcmp(token, "ctf"))
{ // draw a ctf client block
int score, ping;
char block[80];
token = COM_Parse(&s);
x = viddef.width / 2 - 160 + atoi(token);
token = COM_Parse(&s);
y = viddef.height / 2 - 120 + atoi(token);
SCR_AddDirtyPoint(x, y);
SCR_AddDirtyPoint(x + 159, y + 31);
token = COM_Parse(&s);
value = atoi(token);
if (value >= MAX_CLIENTS || value < 0)
Com_Error(ERR_DROP, "client >= MAX_CLIENTS");
ci = &cl.clientinfo[value];
token = COM_Parse(&s);
score = atoi(token);
token = COM_Parse(&s);
ping = atoi(token);
if (ping > 999)
ping = 999;
sprintf(block, "%3d %3d %-12.12s", score, ping, ci->name);
if (value == cl.playernum)
DrawAltString(x, y, block);
else
DrawString(x, y, block);
continue;
}
if (!strcmp(token, "picn"))
{ // draw a pic from a name
token = COM_Parse(&s);
SCR_AddDirtyPoint(x, y);
SCR_AddDirtyPoint(x + 23, y + 23);
re.DrawPic(x, y, token);
continue;
}
if (!strcmp(token, "num"))
{ // draw a number
token = COM_Parse(&s);
width = atoi(token);
token = COM_Parse(&s);
value = cl.frame.playerstate.stats[atoi(token)];
SCR_DrawField(x, y, 0, width, value);
continue;
}
if (!strcmp(token, "hnum"))
{ // health number
int color;
width = 3;
value = cl.frame.playerstate.stats[STAT_HEALTH];
if (value > 25)
color = 0; // green
else if (value > 0)
color = (cl.frame.serverframe >> 2) & 1; // flash
else
color = 1;
if (cl.frame.playerstate.stats[STAT_FLASHES] & 1)
re.DrawPic(x, y, "field_3");
SCR_DrawField(x, y, color, width, value);
continue;
}
if (!strcmp(token, "anum"))
{ // ammo number
int color;
width = 3;
value = cl.frame.playerstate.stats[STAT_AMMO];
if (value > 5)
color = 0; // green
else if (value >= 0)
color = (cl.frame.serverframe >> 2) & 1; // flash
else
continue; // negative number = don't show
if (cl.frame.playerstate.stats[STAT_FLASHES] & 4)
re.DrawPic(x, y, "field_3");
SCR_DrawField(x, y, color, width, value);
continue;
}
if (!strcmp(token, "rnum"))
{ // armor number
int color;
width = 3;
value = cl.frame.playerstate.stats[STAT_ARMOR];
if (value < 1)
continue;
color = 0; // green
if (cl.frame.playerstate.stats[STAT_FLASHES] & 2)
re.DrawPic(x, y, "field_3");
SCR_DrawField(x, y, color, width, value);
continue;
}
if (!strcmp(token, "stat_string"))
{
token = COM_Parse(&s);
index = atoi(token);
if (index < 0 || index >= MAX_CONFIGSTRINGS)
Com_Error(ERR_DROP, "Bad stat_string index");
index = cl.frame.playerstate.stats[index];
if (index < 0 || index >= MAX_CONFIGSTRINGS)
Com_Error(ERR_DROP, "Bad stat_string index");
DrawString(x, y, cl.configstrings[index]);
continue;
}
if (!strcmp(token, "cstring"))
{
token = COM_Parse(&s);
DrawHUDString(token, x, y, 320, 0);
continue;
}
if (!strcmp(token, "string"))
{
token = COM_Parse(&s);
DrawString(x, y, token);
continue;
}
if (!strcmp(token, "cstring2"))
{
token = COM_Parse(&s);
DrawHUDString(token, x, y, 320, 0x80);
continue;
}
if (!strcmp(token, "string2"))
{
token = COM_Parse(&s);
DrawAltString(x, y, token);
continue;
}
if (!strcmp(token, "if"))
{ // draw a number
token = COM_Parse(&s);
value = cl.frame.playerstate.stats[atoi(token)];
if (!value)
{ // skip to endif
while (s && strcmp(token, "endif"))
{
token = COM_Parse(&s);
}
}
continue;
}
}
}
/*
================
SCR_DrawStats
The status bar is a small layout program that
is based on the stats array
================
*/
void SCR_DrawStats(void)
{
SCR_ExecuteLayoutString(cl.configstrings[CS_STATUSBAR]);
}
/*
================
SCR_DrawLayout
================
*/
#define STAT_LAYOUTS 13
void SCR_DrawLayout(void)
{
if (!cl.frame.playerstate.stats[STAT_LAYOUTS])
return;
SCR_ExecuteLayoutString(cl.layout);
}
//=======================================================
/*
==================
SCR_UpdateScreen
This is called every frame, and can also be called explicitly to flush
text to the screen.
==================
*/
void SCR_UpdateScreen(void)
{
int i;
int numframes;
float separation[2] = { 0, 0 };
// if the screen is disabled (loading plaque is up, or vid mode changing)
// do nothing at all
if (cls.disable_screen)
{
if (Sys_Milliseconds() - cls.disable_screen > 120000)
{
cls.disable_screen = 0;
Com_Printf("Loading plaque timed out.\n");
}
return;
}
if (!scr_initialized || !con.initialized)
{
return; // not initialized yet
}
/*
* range check cl_camera_separation so we don't
* inadvertently fry someone's brain
*/
if (cl_stereo_separation->value > 1.0)
{
Cvar_SetValue("cl_stereo_separation", 1.0);
}
else if (cl_stereo_separation->value < 0.0)
{
Cvar_SetValue("cl_stereo_separation", 0.0);
}
if (cl_stereo->value)
{
numframes = 2;
separation[0] = -cl_stereo_separation->value / 2;
separation[1] = cl_stereo_separation->value / 2;
}
else
{
separation[0] = 0;
separation[1] = 0;
numframes = 1;
}
for (i = 0; i < numframes; i++)
{
re.BeginFrame(separation[i]);
if (scr_draw_loading == 2)
{
// loading plaque over black screen
int w, h;
re.CinematicSetPalette(NULL);
scr_draw_loading = false;
re.DrawGetPicSize(&w, &h, "loading");
re.DrawPic((viddef.width - w) / 2, (viddef.height - h) / 2, "loading");
}
else if (cl.cinematictime > 0)
{
// if a cinematic is supposed to be running,
// handle menus and console specially
if (cls.key_dest == key_menu)
{
if (cl.cinematicpalette_active)
{
re.CinematicSetPalette(NULL);
cl.cinematicpalette_active = false;
}
M_Draw();
}
else if (cls.key_dest == key_console)
{
if (cl.cinematicpalette_active)
{
re.CinematicSetPalette(NULL);
cl.cinematicpalette_active = false;
}
SCR_DrawConsole();
}
else
{
SCR_DrawCinematic();
}
}
else
{
// make sure the game palette is active
if (cl.cinematicpalette_active)
{
re.CinematicSetPalette(NULL);
cl.cinematicpalette_active = false;
}
// do 3D refresh drawing, and then update the screen
SCR_CalcVrect();
// clear any dirty part of the background
SCR_TileClear();
V_RenderView(separation[i]);
SCR_DrawStats();
if (cl.frame.playerstate.stats[STAT_LAYOUTS] & 1)
{
SCR_DrawLayout();
}
if (cl.frame.playerstate.stats[STAT_LAYOUTS] & 2)
{
CL_DrawInventory();
}
SCR_DrawNet();
SCR_CheckDrawCenterString();
if (scr_timegraph->value)
{
SCR_DebugGraph(cls.frametime * 300, 0);
}
if (scr_debuggraph->value || scr_timegraph->value || scr_netgraph->value)
{
SCR_DrawDebugGraph();
}
SCR_DrawPause();
SCR_DrawConsole();
M_Draw();
SCR_DrawLoading();
}
}
re.EndFrame();
}
Reference in new issue View Git Blame Copy Permalink