#include "quakedef.h"

#include "cl_video.h"

#include "image.h"

#include "jpeg.h"

#include "image_png.h"

#include "cl_collision.h"

#include "libcurl.h"

#include "csprogs.h"

#include "r_stats.h"

#ifdef CONFIG_VIDEO_CAPTURE

#include "cap_avi.h"

#include "cap_ogg.h"

#endif

// we have to include snd_main.h here only to get access to snd_renderbuffer->format.speed when writing the AVI headers

#include "snd_main.h"

cvar_t scr_viewsize = {CF_CLIENT | CF_ARCHIVE, "viewsize","100", "how large the view should be, 110 disables inventory bar, 120 disables status bar"};

cvar_t scr_fov = {CF_CLIENT | CF_ARCHIVE, "fov","90", "field of vision, 1-170 degrees, default 90, some players use 110-130"};

cvar_t scr_conalpha = {CF_CLIENT | CF_ARCHIVE, "scr_conalpha", "0.9", "opacity of console background gfx/conback (when console isn't forced fullscreen)"};

cvar_t scr_conalphafactor = {CF_CLIENT | CF_ARCHIVE, "scr_conalphafactor", "1", "opacity of console background gfx/conback relative to scr_conalpha; when 0, gfx/conback is not drawn"};

cvar_t scr_conalpha2factor = {CF_CLIENT | CF_ARCHIVE, "scr_conalpha2factor", "0", "opacity of console background gfx/conback2 relative to scr_conalpha; when 0, gfx/conback2 is not drawn"};

cvar_t scr_conalpha3factor = {CF_CLIENT | CF_ARCHIVE, "scr_conalpha3factor", "0", "opacity of console background gfx/conback3 relative to scr_conalpha; when 0, gfx/conback3 is not drawn"};

cvar_t scr_conbrightness = {CF_CLIENT | CF_ARCHIVE, "scr_conbrightness", "1", "brightness of console background (0 = black, 1 = image)"};

cvar_t scr_conforcewhiledisconnected = {CF_CLIENT, "scr_conforcewhiledisconnected", "1", "1 forces fullscreen console while disconnected, 2 also forces it when the listen server has started but the client is still loading"};

cvar_t scr_conheight = {CF_CLIENT | CF_ARCHIVE, "scr_conheight", "0.5", "fraction of screen height occupied by console (reduced as necessary for visibility of loading progress and infobar)"};

cvar_t scr_conscroll_x = {CF_CLIENT | CF_ARCHIVE, "scr_conscroll_x", "0", "scroll speed of gfx/conback in x direction"};

cvar_t scr_conscroll_y = {CF_CLIENT | CF_ARCHIVE, "scr_conscroll_y", "0", "scroll speed of gfx/conback in y direction"};

cvar_t scr_conscroll2_x = {CF_CLIENT | CF_ARCHIVE, "scr_conscroll2_x", "0", "scroll speed of gfx/conback2 in x direction"};

cvar_t scr_conscroll2_y = {CF_CLIENT | CF_ARCHIVE, "scr_conscroll2_y", "0", "scroll speed of gfx/conback2 in y direction"};

cvar_t scr_conscroll3_x = {CF_CLIENT | CF_ARCHIVE, "scr_conscroll3_x", "0", "scroll speed of gfx/conback3 in x direction"};

cvar_t scr_conscroll3_y = {CF_CLIENT | CF_ARCHIVE, "scr_conscroll3_y", "0", "scroll speed of gfx/conback3 in y direction"};

#ifdef CONFIG_MENU

cvar_t scr_menuforcewhiledisconnected = {CF_CLIENT, "scr_menuforcewhiledisconnected", "0", "forces menu while disconnected"};

#endif

cvar_t scr_centertime = {CF_CLIENT, "scr_centertime","2", "how long centerprint messages show"};

cvar_t scr_showram = {CF_CLIENT | CF_ARCHIVE, "showram","1", "show ram icon if low on surface cache memory (not used)"};

cvar_t scr_showturtle = {CF_CLIENT | CF_ARCHIVE, "showturtle","0", "show turtle icon when framerate is too low"};

cvar_t scr_showpause = {CF_CLIENT | CF_ARCHIVE, "showpause","1", "show pause icon when game is paused"};

cvar_t scr_showbrand = {CF_CLIENT, "showbrand","0", "shows gfx/brand.tga in a corner of the screen (different values select different positions, including centered)"};

cvar_t scr_printspeed = {CF_CLIENT, "scr_printspeed","0", "speed of intermission printing (episode end texts), a value of 0 disables the slow printing"};

cvar_t scr_loadingscreen_background = {CF_CLIENT, "scr_loadingscreen_background","0", "show the last visible background during loading screen (costs one screenful of video memory)"};

cvar_t scr_loadingscreen_scale = {CF_CLIENT, "scr_loadingscreen_scale","1", "scale factor of the background"};

cvar_t scr_loadingscreen_scale_base = {CF_CLIENT, "scr_loadingscreen_scale_base","0", "0 = console pixels, 1 = video pixels"};

cvar_t scr_loadingscreen_scale_limit = {CF_CLIENT, "scr_loadingscreen_scale_limit","0", "0 = no limit, 1 = until first edge hits screen edge, 2 = until last edge hits screen edge, 3 = until width hits screen width, 4 = until height hits screen height"};

cvar_t scr_loadingscreen_picture = {CF_CLIENT, "scr_loadingscreen_picture", "gfx/loading", "picture shown during loading"};

cvar_t scr_loadingscreen_count = {CF_CLIENT, "scr_loadingscreen_count","1", "number of loading screen files to use randomly (named loading.tga, loading2.tga, loading3.tga, ...)"};

cvar_t scr_loadingscreen_firstforstartup = {CF_CLIENT, "scr_loadingscreen_firstforstartup","0", "remove loading.tga from random scr_loadingscreen_count selection and only display it on client startup, 0 = normal, 1 = firstforstartup"};

cvar_t scr_loadingscreen_barcolor = {CF_CLIENT, "scr_loadingscreen_barcolor", "0 0 1", "rgb color of loadingscreen progress bar"};

cvar_t scr_loadingscreen_barheight = {CF_CLIENT, "scr_loadingscreen_barheight", "8", "the height of the loadingscreen progress bar"};

cvar_t scr_loadingscreen_maxfps = {CF_CLIENT, "scr_loadingscreen_maxfps", "20", "maximum FPS for loading screen so it will not update very often (this reduces loading time with lots of models)"};

cvar_t scr_infobar_height = {CF_CLIENT, "scr_infobar_height", "8", "the height of the infobar items"};

cvar_t scr_sbarscale = {CF_CLIENT | CF_READONLY, "scr_sbarscale", "1", "current vid_height/vid_conheight, for compatibility with csprogs that read this cvar (found in Fitzquake-derived engines and FTEQW; despite the name it's not specific to the status bar)"};

cvar_t vid_conwidthauto = {CF_CLIENT | CF_ARCHIVE, "vid_conwidthauto", "1", "automatically update vid_conwidth to match aspect ratio"};

cvar_t vid_conwidth = {CF_CLIENT | CF_ARCHIVE, "vid_conwidth", "640", "virtual width of 2D graphics system (note: changes may be overwritten, see vid_conwidthauto)"};

cvar_t vid_conheight = {CF_CLIENT | CF_ARCHIVE, "vid_conheight", "480", "virtual height of 2D graphics system"};

cvar_t vid_pixelheight = {CF_CLIENT | CF_ARCHIVE, "vid_pixelheight", "1", "adjusts vertical field of vision to account for non-square pixels (1280x1024 on a CRT monitor for example)"};

cvar_t scr_screenshot_jpeg = {CF_CLIENT | CF_ARCHIVE, "scr_screenshot_jpeg","1", "save jpeg instead of targa or PNG"};

cvar_t scr_screenshot_jpeg_quality = {CF_CLIENT | CF_ARCHIVE, "scr_screenshot_jpeg_quality","0.9", "image quality of saved jpeg"};

cvar_t scr_screenshot_png = {CF_CLIENT | CF_ARCHIVE, "scr_screenshot_png","0", "save png instead of targa"};

cvar_t scr_screenshot_gammaboost = {CF_CLIENT | CF_ARCHIVE, "scr_screenshot_gammaboost","1", "gamma correction on saved screenshots and videos, 1.0 saves unmodified images"};

cvar_t scr_screenshot_alpha = {CF_CLIENT, "scr_screenshot_alpha","0", "try to write an alpha channel to screenshots (debugging feature)"};

cvar_t scr_screenshot_timestamp = {CF_CLIENT | CF_ARCHIVE, "scr_screenshot_timestamp", "1", "use a timestamp based number of the type YYYYMMDDHHMMSSsss instead of sequential numbering"};

// scr_screenshot_name is defined in fs.c

#ifdef CONFIG_VIDEO_CAPTURE

cvar_t cl_capturevideo = {CF_CLIENT, "cl_capturevideo", "0", "enables saving of video to a .avi file using uncompressed I420 colorspace and PCM audio, note that scr_screenshot_gammaboost affects the brightness of the output)"};

cvar_t cl_capturevideo_demo_stop = {CF_CLIENT | CF_ARCHIVE, "cl_capturevideo_demo_stop", "1", "automatically stops video recording when demo ends"};

cvar_t cl_capturevideo_printfps = {CF_CLIENT | CF_ARCHIVE, "cl_capturevideo_printfps", "1", "prints the frames per second captured in capturevideo (is only written to stdout and any log file, not to the console as that would be visible on the video), value is seconds of wall time between prints"};

cvar_t cl_capturevideo_width = {CF_CLIENT | CF_ARCHIVE, "cl_capturevideo_width", "0", "scales all frames to this resolution before saving the video"};

cvar_t cl_capturevideo_height = {CF_CLIENT | CF_ARCHIVE, "cl_capturevideo_height", "0", "scales all frames to this resolution before saving the video"};

cvar_t cl_capturevideo_realtime = {CF_CLIENT, "cl_capturevideo_realtime", "0", "causes video saving to operate in realtime (mostly useful while playing, not while capturing demos), this can produce a much lower quality video due to poor sound/video sync and will abort saving if your machine stalls for over a minute"};

cvar_t cl_capturevideo_fps = {CF_CLIENT | CF_ARCHIVE, "cl_capturevideo_fps", "30", "how many frames per second to save (29.97 for NTSC, 30 for typical PC video, 15 can be useful)"};

cvar_t cl_capturevideo_nameformat = {CF_CLIENT | CF_ARCHIVE, "cl_capturevideo_nameformat", "dpvideo", "prefix for saved videos (the date is encoded using strftime escapes)"};

cvar_t cl_capturevideo_number = {CF_CLIENT | CF_ARCHIVE, "cl_capturevideo_number", "1", "number to append to video filename, incremented each time a capture begins"};

cvar_t cl_capturevideo_ogg = {CF_CLIENT | CF_ARCHIVE, "cl_capturevideo_ogg", "1", "save captured video data as Ogg/Vorbis/Theora streams"};

cvar_t cl_capturevideo_framestep = {CF_CLIENT | CF_ARCHIVE, "cl_capturevideo_framestep", "1", "when set to n >= 1, render n frames to capture one (useful for motion blur like effects)"};

#endif

cvar_t r_letterbox = {CF_CLIENT, "r_letterbox", "0", "reduces vertical height of view to simulate a letterboxed movie effect (can be used by mods for cutscenes)"};

cvar_t r_stereo_separation = {CF_CLIENT, "r_stereo_separation", "4", "separation distance of eyes in the world (negative values are only useful for cross-eyed viewing)"};

cvar_t r_stereo_sidebyside = {CF_CLIENT, "r_stereo_sidebyside", "0", "side by side views for those who can't afford glasses but can afford eye strain (note: use a negative r_stereo_separation if you want cross-eyed viewing)"};

cvar_t r_stereo_horizontal = {CF_CLIENT, "r_stereo_horizontal", "0", "aspect skewed side by side view for special decoder/display hardware"};

cvar_t r_stereo_vertical = {CF_CLIENT, "r_stereo_vertical", "0", "aspect skewed top and bottom view for special decoder/display hardware"};

cvar_t r_stereo_redblue = {CF_CLIENT, "r_stereo_redblue", "0", "red/blue anaglyph stereo glasses (note: most of these glasses are actually red/cyan, try that one too)"};

cvar_t r_stereo_redcyan = {CF_CLIENT, "r_stereo_redcyan", "0", "red/cyan anaglyph stereo glasses, the kind given away at drive-in movies like Creature From The Black Lagoon In 3D"};

cvar_t r_stereo_redgreen = {CF_CLIENT, "r_stereo_redgreen", "0", "red/green anaglyph stereo glasses (for those who don't mind yellow)"};

cvar_t r_stereo_angle = {CF_CLIENT, "r_stereo_angle", "0", "separation angle of eyes (makes the views look different directions, as an example, 90 gives a 90 degree separation where the views are 45 degrees left and 45 degrees right)"};

cvar_t scr_stipple = {CF_CLIENT, "scr_stipple", "0", "interlacing-like stippling of the display"};

cvar_t scr_refresh = {CF_CLIENT, "scr_refresh", "1", "allows you to completely shut off rendering for benchmarking purposes"};

cvar_t scr_screenshot_name_in_mapdir = {CF_CLIENT | CF_ARCHIVE, "scr_screenshot_name_in_mapdir", "0", "if set to 1, screenshots are placed in a subdirectory named like the map they are from"};

cvar_t net_graph = {CF_CLIENT | CF_ARCHIVE, "net_graph", "0", "shows a graph of packet sizes and other information, 0 = off, 1 = show client netgraph, 2 = show client and server netgraphs (when hosting a server)"};

cvar_t cl_demo_mousegrab = {CF_CLIENT, "cl_demo_mousegrab", "0", "Allows reading the mouse input while playing demos. Useful for camera mods developed in csqc. (0: never, 1: always)"};

cvar_t timedemo_screenshotframelist = {CF_CLIENT, "timedemo_screenshotframelist", "", "when performing a timedemo, take screenshots of each frame in this space-separated list - example: 1 201 401"};

cvar_t vid_touchscreen_outlinealpha = {CF_CLIENT, "vid_touchscreen_outlinealpha", "0", "opacity of touchscreen area outlines"};

cvar_t vid_touchscreen_overlayalpha = {CF_CLIENT, "vid_touchscreen_overlayalpha", "0.25", "opacity of touchscreen area icons"};

extern cvar_t sbar_info_pos;

extern cvar_t r_fog_clear;

int jpeg_supported = false;

qbool scr_initialized; // ready to draw

qbool scr_loading = false; // we are in a loading screen

unsigned int scr_con_current;

static unsigned int scr_con_margin_bottom;

extern int con_vislines;

extern int cl_punchangle_applied;

static void SCR_ScreenShot_f(cmd_state_t *cmd);

static void R_Envmap_f(cmd_state_t *cmd);

// backend

void R_ClearScreen(qbool fogcolor);

/*

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

CENTER PRINTING

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

*/

char scr_centerstring[MAX_INPUTLINE];

float scr_centertime_start; // for slow victory printing

float scr_centertime_off;

int scr_center_lines;

int scr_erase_lines;

int scr_erase_center;

char scr_infobarstring[MAX_INPUTLINE];

float scr_infobartime_off;

/*

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

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)

{

scr_centertime_off = scr_centertime.value;

scr_centertime_start = cl.time;

// Print the message to the console and update the scr buffer

// but only if it's different to the previous message

if (strcmp(str, scr_centerstring) == 0)

return;

dp_strlcpy(scr_centerstring, str, sizeof(scr_centerstring));

scr_center_lines = 1;

if (str[0] == '\0') // happens when stepping out of a centreprint trigger on alk1.2 start.bsp

return;

Con_CenterPrint(str);

// count the number of lines for centering

while (*str)

{

if (*str == '\n')

scr_center_lines++;

str++;

}

}

/*

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

SCR_Centerprint_f

Print something to the center of the screen using SCR_Centerprint

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

*/

static void SCR_Centerprint_f (cmd_state_t *cmd)

{

char msg[MAX_INPUTLINE];

unsigned int i, c, p;

c = Cmd_Argc(cmd);

if(c >= 2)

{

// Merge all the cprint arguments into one string

dp_strlcpy(msg, Cmd_Argv(cmd,1), sizeof(msg));

for(i = 2; i < c; ++i)

{

dp_strlcat(msg, " ", sizeof(msg));

dp_strlcat(msg, Cmd_Argv(cmd, i), sizeof(msg));

}

c = (unsigned int)strlen(msg);

for(p = 0, i = 0; i < c; ++i)

{

if(msg[i] == '\\')

{

if(msg[i+1] == 'n')

msg[p++] = '\n';

else if(msg[i+1] == '\\')

msg[p++] = '\\';

else {

msg[p++] = '\\';

msg[p++] = msg[i+1];

}

++i;

} else {

msg[p++] = msg[i];

}

}

msg[p] = '\0';

SCR_CenterPrint(msg);

}

}

static void SCR_DrawCenterString (void)

{

char *start;

int x, y;

int remaining;

int color;

if(cl.intermission == 2) // in finale,

if(sb_showscores) // make TAB hide the finale message (sb_showscores overrides finale in sbar.c)

return;

if(scr_centertime.value <= 0 && !cl.intermission)

return;

// the finale prints the characters one at a time, except if printspeed is an absurdly high value

if (cl.intermission && scr_printspeed.value > 0 && scr_printspeed.value < 1000000)

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

else

remaining = 9999;

scr_erase_center = 0;

start = scr_centerstring;

if (remaining < 1)

return;

if (scr_center_lines <= 4)

y = (int)(vid_conheight.integer*0.35);

else

y = 48;

color = -1;

do

{

// scan the number of characters on the line, not counting color codes

char *newline = strchr(start, '\n');

int l = newline ? (newline - start) : (int)strlen(start);

float width = DrawQ_TextWidth(start, l, 8, 8, false, FONT_CENTERPRINT);

x = (int) (vid_conwidth.integer - width)/2;

if (l > 0)

{

if (remaining < l)

l = remaining;

DrawQ_String(x, y, start, l, 8, 8, 1, 1, 1, 1, 0, &color, false, FONT_CENTERPRINT);

remaining -= l;

if (remaining <= 0)

return;

}

y += 8;

if (!newline)

break;

start = newline + 1; // skip the \n

} while (1);

}

static void SCR_CheckDrawCenterString (void)

{

if (scr_center_lines > scr_erase_lines)

scr_erase_lines = scr_center_lines;

if (cl.time > cl.oldtime)

scr_centertime_off -= cl.time - cl.oldtime;

// don't draw if this is a normal stats-screen intermission,

// only if it is not an intermission, or a finale intermission

if (cl.intermission == 1)

return;

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

return;

if (key_dest != key_game)

return;

SCR_DrawCenterString ();

}

static void SCR_DrawNetGraph_DrawGraph (int graphx, int graphy, int graphwidth, int graphheight, float graphscale, int graphlimit, const char *label, float textsize, int packetcounter, netgraphitem_t *netgraph)

{

netgraphitem_t *graph;

int j, x, y;

int totalbytes = 0;

char bytesstring[128];

float g[NETGRAPH_PACKETS][7];

float *a;

float *b;

DrawQ_Fill(graphx, graphy, graphwidth, graphheight + textsize * 2, 0, 0, 0, 0.5, 0);

// draw the bar graph itself

memset(g, 0, sizeof(g));

for (j = 0;j < NETGRAPH_PACKETS;j++)

{

graph = netgraph + j;

g[j][0] = 1.0f - 0.25f * (host.realtime - graph->time);

g[j][1] = 1.0f;

g[j][2] = 1.0f;

g[j][3] = 1.0f;

g[j][4] = 1.0f;

g[j][5] = 1.0f;

g[j][6] = 1.0f;

if (graph->unreliablebytes == NETGRAPH_LOSTPACKET)

g[j][1] = 0.00f;

else if (graph->unreliablebytes == NETGRAPH_CHOKEDPACKET)

g[j][2] = 0.90f;

else

{

if(netgraph[j].time >= netgraph[(j+NETGRAPH_PACKETS-1)%NETGRAPH_PACKETS].time)

if(graph->unreliablebytes + graph->reliablebytes + graph->ackbytes >= graphlimit * (netgraph[j].time - netgraph[(j+NETGRAPH_PACKETS-1)%NETGRAPH_PACKETS].time))

g[j][2] = 0.98f;

g[j][3] = 1.0f - graph->unreliablebytes * graphscale;

g[j][4] = g[j][3] - graph->reliablebytes * graphscale;

g[j][5] = g[j][4] - graph->ackbytes * graphscale;

// count bytes in the last second

if (host.realtime - graph->time < 1.0f)

totalbytes += graph->unreliablebytes + graph->reliablebytes + graph->ackbytes;

}

if(graph->cleartime >= 0)

g[j][6] = 0.5f + 0.5f * (2.0 / M_PI) * atan((M_PI / 2.0) * (graph->cleartime - graph->time));

g[j][1] = bound(0.0f, g[j][1], 1.0f);

g[j][2] = bound(0.0f, g[j][2], 1.0f);

g[j][3] = bound(0.0f, g[j][3], 1.0f);

g[j][4] = bound(0.0f, g[j][4], 1.0f);

g[j][5] = bound(0.0f, g[j][5], 1.0f);

g[j][6] = bound(0.0f, g[j][6], 1.0f);

}

// render the lines for the graph

for (j = 0;j < NETGRAPH_PACKETS;j++)

{

a = g[j];

b = g[(j+1)%NETGRAPH_PACKETS];

if (a[0] < 0.0f || b[0] > 1.0f || b[0] < a[0])

continue;

DrawQ_Line(1, graphx + graphwidth * a[0], graphy + graphheight * a[2], graphx + graphwidth * b[0], graphy + graphheight * b[2], 1.0f, 1.0f, 1.0f, 1.0f, 0);

DrawQ_Line(1, graphx + graphwidth * a[0], graphy + graphheight * a[1], graphx + graphwidth * b[0], graphy + graphheight * b[1], 1.0f, 0.0f, 0.0f, 1.0f, 0);

DrawQ_Line(1, graphx + graphwidth * a[0], graphy + graphheight * a[5], graphx + graphwidth * b[0], graphy + graphheight * b[5], 0.0f, 1.0f, 0.0f, 1.0f, 0);

DrawQ_Line(1, graphx + graphwidth * a[0], graphy + graphheight * a[4], graphx + graphwidth * b[0], graphy + graphheight * b[4], 1.0f, 1.0f, 1.0f, 1.0f, 0);

DrawQ_Line(1, graphx + graphwidth * a[0], graphy + graphheight * a[3], graphx + graphwidth * b[0], graphy + graphheight * b[3], 1.0f, 0.5f, 0.0f, 1.0f, 0);

DrawQ_Line(1, graphx + graphwidth * a[0], graphy + graphheight * a[6], graphx + graphwidth * b[0], graphy + graphheight * b[6], 0.0f, 0.0f, 1.0f, 1.0f, 0);

}

x = graphx;

y = graphy + graphheight;

dpsnprintf(bytesstring, sizeof(bytesstring), "%i", totalbytes);

DrawQ_String(x, y, label , 0, textsize, textsize, 1.0f, 1.0f, 1.0f, 1.0f, 0, NULL, false, FONT_DEFAULT);y += textsize;

DrawQ_String(x, y, bytesstring, 0, textsize, textsize, 1.0f, 1.0f, 1.0f, 1.0f, 0, NULL, false, FONT_DEFAULT);y += textsize;

}

/*

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

SCR_DrawNetGraph

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

*/

static void SCR_DrawNetGraph (void)

{

int i, separator1, separator2, graphwidth, graphheight, netgraph_x, netgraph_y, textsize, index, netgraphsperrow, graphlimit;

float graphscale;

netconn_t *c;

char vabuf[1024];

if (cls.state != ca_connected)

return;

if (!cls.netcon)

return;

if (!net_graph.integer)

return;

separator1 = 2;

separator2 = 4;

textsize = 8;

graphwidth = 120;

graphheight = 70;

graphscale = 1.0f / 1500.0f;

graphlimit = cl_rate.integer;

netgraphsperrow = (vid_conwidth.integer + separator2) / (graphwidth * 2 + separator1 + separator2);

netgraphsperrow = max(netgraphsperrow, 1);

index = 0;

netgraph_x = (vid_conwidth.integer + separator2) - (1 + (index % netgraphsperrow)) * (graphwidth * 2 + separator1 + separator2);

netgraph_y = (vid_conheight.integer - 48 - sbar_info_pos.integer + separator2) - (1 + (index / netgraphsperrow)) * (graphheight + textsize + separator2);

c = cls.netcon;

SCR_DrawNetGraph_DrawGraph(netgraph_x , netgraph_y, graphwidth, graphheight, graphscale, graphlimit, "incoming", textsize, c->incoming_packetcounter, c->incoming_netgraph);

SCR_DrawNetGraph_DrawGraph(netgraph_x + graphwidth + separator1, netgraph_y, graphwidth, graphheight, graphscale, graphlimit, "outgoing", textsize, c->outgoing_packetcounter, c->outgoing_netgraph);

index++;

if (sv.active && net_graph.integer >= 2)

{

for (i = 0;i < svs.maxclients;i++)

{

c = svs.clients[i].netconnection;

if (!c)

continue;

netgraph_x = (vid_conwidth.integer + separator2) - (1 + (index % netgraphsperrow)) * (graphwidth * 2 + separator1 + separator2);

netgraph_y = (vid_conheight.integer - 48 + separator2) - (1 + (index / netgraphsperrow)) * (graphheight + textsize + separator2);

SCR_DrawNetGraph_DrawGraph(netgraph_x , netgraph_y, graphwidth, graphheight, graphscale, graphlimit, va(vabuf, sizeof(vabuf), "%s", svs.clients[i].name), textsize, c->outgoing_packetcounter, c->outgoing_netgraph);

SCR_DrawNetGraph_DrawGraph(netgraph_x + graphwidth + separator1, netgraph_y, graphwidth, graphheight, graphscale, graphlimit, "" , textsize, c->incoming_packetcounter, c->incoming_netgraph);

index++;

}

}

}

/*

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

SCR_DrawTurtle

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

*/

static void SCR_DrawTurtle (void)

{

static int count;

if (cls.state != ca_connected)

return;

if (!scr_showturtle.integer)

return;

if (cl.realframetime < 0.1)

{

count = 0;

return;

}

count++;

if (count < 3)

return;

DrawQ_Pic (0, 0, Draw_CachePic ("gfx/turtle"), 0, 0, 1, 1, 1, 1, 0);

}

/*

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

SCR_DrawNet

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

*/

static void SCR_DrawNet (void)

{

if (cls.state != ca_connected)

return;

if (host.realtime - cl.last_received_message < 0.3)

return;

if (cls.demoplayback)

return;

DrawQ_Pic (64, 0, Draw_CachePic ("gfx/net"), 0, 0, 1, 1, 1, 1, 0);

}

/*

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

DrawPause

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

*/

static void SCR_DrawPause (void)

{

cachepic_t *pic;

if (cls.state != ca_connected)

return;

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

return;

if (!cl.paused)

return;

pic = Draw_CachePic ("gfx/pause");

DrawQ_Pic ((vid_conwidth.integer - Draw_GetPicWidth(pic))/2, (vid_conheight.integer - Draw_GetPicHeight(pic))/2, pic, 0, 0, 1, 1, 1, 1, 0);

}

/*

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

SCR_DrawBrand

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

*/

static void SCR_DrawBrand (void)

{

cachepic_t *pic;

float x, y;

if (!scr_showbrand.value)

return;

pic = Draw_CachePic ("gfx/brand");

switch ((int)scr_showbrand.value)

{

case 1: // bottom left

x = 0;

y = vid_conheight.integer - Draw_GetPicHeight(pic);

break;

case 2: // bottom centre

x = (vid_conwidth.integer - Draw_GetPicWidth(pic)) / 2;

y = vid_conheight.integer - Draw_GetPicHeight(pic);

break;

case 3: // bottom right

x = vid_conwidth.integer - Draw_GetPicWidth(pic);

y = vid_conheight.integer - Draw_GetPicHeight(pic);

break;

case 4: // centre right

x = vid_conwidth.integer - Draw_GetPicWidth(pic);

y = (vid_conheight.integer - Draw_GetPicHeight(pic)) / 2;

break;

case 5: // top right

x = vid_conwidth.integer - Draw_GetPicWidth(pic);

y = 0;

break;

case 6: // top centre

x = (vid_conwidth.integer - Draw_GetPicWidth(pic)) / 2;

y = 0;

break;

case 7: // top left

x = 0;

y = 0;

break;

case 8: // centre left

x = 0;

y = (vid_conheight.integer - Draw_GetPicHeight(pic)) / 2;

break;

default:

return;

}

DrawQ_Pic (x, y, pic, 0, 0, 1, 1, 1, 1, 0);

}

/*

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

SCR_DrawQWDownload

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

*/

static int SCR_DrawQWDownload(int offset)

{

// sync with SCR_InfobarHeight

int len;

float x, y;

float size = scr_infobar_height.value;

char temp[256];

if (!cls.qw_downloadname[0])

{

cls.qw_downloadspeedrate = 0;

cls.qw_downloadspeedtime = host.realtime;

cls.qw_downloadspeedcount = 0;

return 0;

}

if (host.realtime >= cls.qw_downloadspeedtime + 1)

{

cls.qw_downloadspeedrate = cls.qw_downloadspeedcount;

cls.qw_downloadspeedtime = host.realtime;

cls.qw_downloadspeedcount = 0;

}

if (cls.protocol == PROTOCOL_QUAKEWORLD)

dpsnprintf(temp, sizeof(temp), "Downloading %s %3i%% (%i) at %i bytes/s", cls.qw_downloadname, cls.qw_downloadpercent, cls.qw_downloadmemorycursize, cls.qw_downloadspeedrate);

else

dpsnprintf(temp, sizeof(temp), "Downloading %s %3i%% (%i/%i) at %i bytes/s", cls.qw_downloadname, cls.qw_downloadpercent, cls.qw_downloadmemorycursize, cls.qw_downloadmemorymaxsize, cls.qw_downloadspeedrate);

len = (int)strlen(temp);

x = (vid_conwidth.integer - DrawQ_TextWidth(temp, len, size, size, true, FONT_INFOBAR)) / 2;

y = vid_conheight.integer - size - offset;

DrawQ_Fill(0, y, vid_conwidth.integer, size, 0, 0, 0, cls.signon == SIGNONS ? 0.5 : 1, 0);

DrawQ_String(x, y, temp, len, size, size, 1, 1, 1, 1, 0, NULL, true, FONT_INFOBAR);

return size;

}

/*

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

SCR_DrawInfobarString

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

*/

static int SCR_DrawInfobarString(int offset)

{

int len;

float x, y;

float size = scr_infobar_height.value;

len = (int)strlen(scr_infobarstring);

x = (vid_conwidth.integer - DrawQ_TextWidth(scr_infobarstring, len, size, size, false, FONT_INFOBAR)) / 2;

y = vid_conheight.integer - size - offset;

DrawQ_Fill(0, y, vid_conwidth.integer, size, 0, 0, 0, cls.signon == SIGNONS ? 0.5 : 1, 0);

DrawQ_String(x, y, scr_infobarstring, len, size, size, 1, 1, 1, 1, 0, NULL, false, FONT_INFOBAR);

return size;

}

/*

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

SCR_DrawCurlDownload

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

*/

static int SCR_DrawCurlDownload(int offset)

{

// sync with SCR_InfobarHeight

int len;

int nDownloads;

int i;

float x, y;

float size = scr_infobar_height.value;

Curl_downloadinfo_t *downinfo;

char temp[256];

char addinfobuf[128];

const char *addinfo;

downinfo = Curl_GetDownloadInfo(&nDownloads, &addinfo, addinfobuf, sizeof(addinfobuf));

if(!downinfo)

return 0;

y = vid_conheight.integer - size * nDownloads - offset;

if(addinfo)

{

len = (int)strlen(addinfo);

x = (vid_conwidth.integer - DrawQ_TextWidth(addinfo, len, size, size, true, FONT_INFOBAR)) / 2;

DrawQ_Fill(0, y - size, vid_conwidth.integer, size, 1, 1, 1, cls.signon == SIGNONS ? 0.8 : 1, 0);

DrawQ_String(x, y - size, addinfo, len, size, size, 0, 0, 0, 1, 0, NULL, true, FONT_INFOBAR);

}

for(i = 0; i != nDownloads; ++i)

{

if(downinfo[i].queued)

dpsnprintf(temp, sizeof(temp), "Still in queue: %s", downinfo[i].filename);

else if(downinfo[i].progress <= 0)

dpsnprintf(temp, sizeof(temp), "Downloading %s ... ???.?%% @ %.1f KiB/s", downinfo[i].filename, downinfo[i].speed / 1024.0);

else

dpsnprintf(temp, sizeof(temp), "Downloading %s ... %5.1f%% @ %.1f KiB/s", downinfo[i].filename, 100.0 * downinfo[i].progress, downinfo[i].speed / 1024.0);

len = (int)strlen(temp);

x = (vid_conwidth.integer - DrawQ_TextWidth(temp, len, size, size, true, FONT_INFOBAR)) / 2;

DrawQ_Fill(0, y + i * size, vid_conwidth.integer, size, 0, 0, 0, cls.signon == SIGNONS ? 0.5 : 1, 0);

DrawQ_String(x, y + i * size, temp, len, size, size, 1, 1, 1, 1, 0, NULL, true, FONT_INFOBAR);

}

Z_Free(downinfo);

return size * (nDownloads + (addinfo ? 1 : 0));

}

/*

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

SCR_DrawInfobar

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

*/

static void SCR_DrawInfobar(void)

{

unsigned int offset = 0;

offset += SCR_DrawQWDownload(offset);

offset += SCR_DrawCurlDownload(offset);

if(scr_infobartime_off > 0)

offset += SCR_DrawInfobarString(offset);

if(!offset && scr_loading)

offset = scr_loadingscreen_barheight.integer;

if(offset != scr_con_margin_bottom)

Con_DPrintf("broken console margin calculation: %d != %d\n", offset, scr_con_margin_bottom);

}

static int SCR_InfobarHeight(void)

{

int offset = 0;

Curl_downloadinfo_t *downinfo;

const char *addinfo;

int nDownloads;

char addinfobuf[128];

if (cl.time > cl.oldtime)

scr_infobartime_off -= cl.time - cl.oldtime;

if(scr_infobartime_off > 0)

offset += 1;

if(cls.qw_downloadname[0])

offset += 1;

downinfo = Curl_GetDownloadInfo(&nDownloads, &addinfo, addinfobuf, sizeof(addinfobuf));

if(downinfo)

{

offset += (nDownloads + (addinfo ? 1 : 0));

Z_Free(downinfo);

}

offset *= scr_infobar_height.value;

return offset;

}

/*

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

SCR_InfoBar_f

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

*/

static void SCR_InfoBar_f(cmd_state_t *cmd)

{

if(Cmd_Argc(cmd) == 3)

{

scr_infobartime_off = atof(Cmd_Argv(cmd, 1));

dp_strlcpy(scr_infobarstring, Cmd_Argv(cmd, 2), sizeof(scr_infobarstring));

}

else

{

Con_Printf("usage:\ninfobar expiretime \"string\"\n");

}

}

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

/*

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

SCR_SetUpToDrawConsole

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

*/

static void SCR_SetUpToDrawConsole (void)

{

#ifdef CONFIG_MENU

static int framecounter = 0;

#endif

Con_CheckResize ();

#ifdef CONFIG_MENU

if (scr_menuforcewhiledisconnected.integer && key_dest == key_game && cls.state == ca_disconnected)

{

if (framecounter >= 2)

MR_ToggleMenu(1);

else

framecounter++;

}

else

framecounter = 0;

#endif

if (scr_conforcewhiledisconnected.integer >= 2 && key_dest == key_game && cls.signon != SIGNONS)

key_consoleactive |= KEY_CONSOLEACTIVE_FORCED;

else if (scr_conforcewhiledisconnected.integer >= 1 && key_dest == key_game && cls.signon != SIGNONS && !sv.active)

key_consoleactive |= KEY_CONSOLEACTIVE_FORCED;

else

key_consoleactive &= ~KEY_CONSOLEACTIVE_FORCED;

// decide on the height of the console

if (key_consoleactive & KEY_CONSOLEACTIVE_USER)

scr_con_current = vid_conheight.integer * scr_conheight.value;

else

scr_con_current = 0; // none visible

}

/*

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

SCR_DrawConsole

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

*/

void SCR_DrawConsole (void)

{

// infobar and loading progress are not drawn simultaneously

scr_con_margin_bottom = SCR_InfobarHeight();

if (!scr_con_margin_bottom && scr_loading)

scr_con_margin_bottom = scr_loadingscreen_barheight.integer;

if (key_consoleactive & KEY_CONSOLEACTIVE_FORCED)

{

// full screen

Con_DrawConsole (vid_conheight.integer - scr_con_margin_bottom, true);

}

else if (scr_con_current)

Con_DrawConsole (min(scr_con_current, vid_conheight.integer - scr_con_margin_bottom), false);

else

con_vislines = 0;

}

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

/*

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

SCR_SizeUp_f

Keybinding command

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

*/

static void SCR_SizeUp_f(cmd_state_t *cmd)

{

Cvar_SetValueQuick(&scr_viewsize, scr_viewsize.value + 10);

}

/*

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

SCR_SizeDown_f

Keybinding command

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

*/

static void SCR_SizeDown_f(cmd_state_t *cmd)

{

Cvar_SetValueQuick(&scr_viewsize, scr_viewsize.value - 10);

}

#ifdef CONFIG_VIDEO_CAPTURE

void SCR_CaptureVideo_EndVideo(void);

#endif

void CL_Screen_Shutdown(void)

{

#ifdef CONFIG_VIDEO_CAPTURE

SCR_CaptureVideo_EndVideo();

#endif

}

void CL_Screen_Init(void)

{

int i;

Cvar_RegisterVariable (&scr_fov);

Cvar_RegisterVariable (&scr_viewsize);

Cvar_RegisterVariable (&scr_conalpha);

Cvar_RegisterVariable (&scr_conalphafactor);

Cvar_RegisterVariable (&scr_conalpha2factor);

Cvar_RegisterVariable (&scr_conalpha3factor);

Cvar_RegisterVariable (&scr_conscroll_x);

Cvar_RegisterVariable (&scr_conscroll_y);

Cvar_RegisterVariable (&scr_conscroll2_x);

Cvar_RegisterVariable (&scr_conscroll2_y);

Cvar_RegisterVariable (&scr_conscroll3_x);

Cvar_RegisterVariable (&scr_conscroll3_y);

Cvar_RegisterVariable (&scr_conbrightness);

Cvar_RegisterVariable (&scr_conforcewhiledisconnected);

Cvar_RegisterVariable (&scr_conheight);

#ifdef CONFIG_MENU

Cvar_RegisterVariable (&scr_menuforcewhiledisconnected);

#endif

Cvar_RegisterVariable (&scr_loadingscreen_background);

Cvar_RegisterVariable (&scr_loadingscreen_scale);

Cvar_RegisterVariable (&scr_loadingscreen_scale_base);

Cvar_RegisterVariable (&scr_loadingscreen_scale_limit);

Cvar_RegisterVariable (&scr_loadingscreen_picture);

Cvar_RegisterVariable (&scr_loadingscreen_count);

Cvar_RegisterVariable (&scr_loadingscreen_firstforstartup);

Cvar_RegisterVariable (&scr_loadingscreen_barcolor);

Cvar_RegisterVariable (&scr_loadingscreen_barheight);

Cvar_RegisterVariable (&scr_loadingscreen_maxfps);

Cvar_RegisterVariable (&scr_infobar_height);

Cvar_RegisterVariable (&scr_showram);

Cvar_RegisterVariable (&scr_showturtle);

Cvar_RegisterVariable (&scr_showpause);

Cvar_RegisterVariable (&scr_showbrand);

Cvar_RegisterVariable (&scr_centertime);

Cvar_RegisterVariable (&scr_printspeed);

Cvar_RegisterVariable (&scr_sbarscale);

Cvar_RegisterVariable (&vid_conwidth);

Cvar_RegisterVariable (&vid_conheight);

Cvar_RegisterVariable (&vid_pixelheight);

Cvar_RegisterVariable (&vid_conwidthauto);

Cvar_RegisterVariable (&scr_screenshot_jpeg);

Cvar_RegisterVariable (&scr_screenshot_jpeg_quality);

Cvar_RegisterVariable (&scr_screenshot_png);

Cvar_RegisterVariable (&scr_screenshot_gammaboost);

Cvar_RegisterVariable (&scr_screenshot_name_in_mapdir);

Cvar_RegisterVariable (&scr_screenshot_alpha);

Cvar_RegisterVariable (&scr_screenshot_timestamp);

#ifdef CONFIG_VIDEO_CAPTURE

Cvar_RegisterVariable (&cl_capturevideo);

Cvar_RegisterVariable (&cl_capturevideo_demo_stop);

Cvar_RegisterVariable (&cl_capturevideo_printfps);

Cvar_RegisterVariable (&cl_capturevideo_width);

Cvar_RegisterVariable (&cl_capturevideo_height);

Cvar_RegisterVariable (&cl_capturevideo_realtime);

Cvar_RegisterVariable (&cl_capturevideo_fps);

Cvar_RegisterVariable (&cl_capturevideo_nameformat);

Cvar_RegisterVariable (&cl_capturevideo_number);

Cvar_RegisterVariable (&cl_capturevideo_ogg);

Cvar_RegisterVariable (&cl_capturevideo_framestep);

#endif

Cvar_RegisterVariable (&r_letterbox);

Cvar_RegisterVariable(&r_stereo_separation);

Cvar_RegisterVariable(&r_stereo_sidebyside);

Cvar_RegisterVariable(&r_stereo_horizontal);

Cvar_RegisterVariable(&r_stereo_vertical);

Cvar_RegisterVariable(&r_stereo_redblue);

Cvar_RegisterVariable(&r_stereo_redcyan);

Cvar_RegisterVariable(&r_stereo_redgreen);

Cvar_RegisterVariable(&r_stereo_angle);

Cvar_RegisterVariable(&scr_stipple);

Cvar_RegisterVariable(&scr_refresh);

Cvar_RegisterVariable(&net_graph);

Cvar_RegisterVirtual(&net_graph, "shownetgraph");

Cvar_RegisterVariable(&cl_demo_mousegrab);

Cvar_RegisterVariable(&timedemo_screenshotframelist);

Cvar_RegisterVariable(&vid_touchscreen_outlinealpha);

Cvar_RegisterVariable(&vid_touchscreen_overlayalpha);

Cvar_RegisterVariable(&r_speeds_graph);

for (i = 0;i < (int)(sizeof(r_speeds_graph_filter)/sizeof(r_speeds_graph_filter[0]));i++)

Cvar_RegisterVariable(&r_speeds_graph_filter[i]);

Cvar_RegisterVariable(&r_speeds_graph_length);

Cvar_RegisterVariable(&r_speeds_graph_seconds);

Cvar_RegisterVariable(&r_speeds_graph_x);

Cvar_RegisterVariable(&r_speeds_graph_y);

Cvar_RegisterVariable(&r_speeds_graph_width);

Cvar_RegisterVariable(&r_speeds_graph_height);

Cvar_RegisterVariable(&r_speeds_graph_maxtimedelta);

Cvar_RegisterVariable(&r_speeds_graph_maxdefault);

// if we want no console, turn it off here too

if (Sys_CheckParm ("-noconsole"))

Cvar_SetQuick(&scr_conforcewhiledisconnected, "0");

Cmd_AddCommand(CF_CLIENT, "cprint", SCR_Centerprint_f, "print something at the screen center");

Cmd_AddCommand(CF_CLIENT, "sizeup",SCR_SizeUp_f, "increase view size (increases viewsize cvar)");

Cmd_AddCommand(CF_CLIENT, "sizedown",SCR_SizeDown_f, "decrease view size (decreases viewsize cvar)");

Cmd_AddCommand(CF_CLIENT, "screenshot",SCR_ScreenShot_f, "takes a screenshot of the next rendered frame");

Cmd_AddCommand(CF_CLIENT, "envmap", R_Envmap_f, "render a cubemap (skybox) of the current scene");

Cmd_AddCommand(CF_CLIENT, "infobar", SCR_InfoBar_f, "display a text in the infobar (usage: infobar expiretime string)");

#ifdef CONFIG_VIDEO_CAPTURE

SCR_CaptureVideo_Ogg_Init();

#endif

scr_initialized = true;

}

/*

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

SCR_ScreenShot_f

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

*/

void SCR_ScreenShot_f(cmd_state_t *cmd)

{

static int shotnumber;

static char old_prefix_name[MAX_QPATH];

char prefix_name[MAX_QPATH];

char filename[MAX_QPATH];

unsigned char *buffer1;

unsigned char *buffer2;

qbool jpeg = (scr_screenshot_jpeg.integer != 0);

qbool png = (scr_screenshot_png.integer != 0) && !jpeg;

char vabuf[1024];

if (Cmd_Argc(cmd) == 2)

{

const char *ext;

dp_strlcpy(filename, Cmd_Argv(cmd, 1), sizeof(filename));

ext = FS_FileExtension(filename);

if (!strcasecmp(ext, "jpg"))

{

jpeg = true;

png = false;

}

else if (!strcasecmp(ext, "tga"))

{

jpeg = false;

png = false;

}

else if (!strcasecmp(ext, "png"))

{

jpeg = false;

png = true;

}

else

{

Con_Printf("screenshot: supplied filename must end in .jpg or .tga or .png\n");

return;

}

}

else if (scr_screenshot_timestamp.integer)

{

int shotnumber100;

// TODO maybe make capturevideo and screenshot use similar name patterns?

Sys_TimeString(vabuf, sizeof(vabuf), "%Y%m%d%H%M%S");

if (scr_screenshot_name_in_mapdir.integer && cl.worldbasename[0])

dpsnprintf(prefix_name, sizeof(prefix_name), "%s/%s%s", cl.worldbasename, scr_screenshot_name.string, vabuf);

else

dpsnprintf(prefix_name, sizeof(prefix_name), "%s%s", scr_screenshot_name.string, vabuf);

// find a file name to save it to

for (shotnumber100 = 0;shotnumber100 < 100;shotnumber100++)

if (!FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s-%02d.tga", fs_gamedir, prefix_name, shotnumber100))

&& !FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s-%02d.jpg", fs_gamedir, prefix_name, shotnumber100))

&& !FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s-%02d.png", fs_gamedir, prefix_name, shotnumber100)))

break;

if (shotnumber100 >= 100)

{

Con_Print("Couldn't create the image file - already 100 shots taken this second!\n");

return;

}

dpsnprintf(filename, sizeof(filename), "screenshots/%s-%02d.%s", prefix_name, shotnumber100, jpeg ? "jpg" : png ? "png" : "tga");

}

else

{

// TODO maybe make capturevideo and screenshot use similar name patterns?

Sys_TimeString(vabuf, sizeof(vabuf), scr_screenshot_name.string);

if (scr_screenshot_name_in_mapdir.integer && cl.worldbasename[0])

dpsnprintf(prefix_name, sizeof(prefix_name), "%s/%s", cl.worldbasename, vabuf);

else

dpsnprintf(prefix_name, sizeof(prefix_name), "%s", vabuf);

// if prefix changed, gamedir or map changed, reset the shotnumber so

// we scan again

// FIXME: should probably do this whenever FS_Rescan or something like that occurs?

if (strcmp(old_prefix_name, prefix_name))

{

dpsnprintf(old_prefix_name, sizeof(old_prefix_name), "%s", prefix_name );

shotnumber = 0;

}

// find a file name to save it to