X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=cl_screen.c;h=d6ba9bb831692527c6056b5cc3c00c9235bc317f;hp=545300425a314ba34041d9f526dd0578557cff45;hb=85a33377d64ae8438e6582a7b8472f5a4bd41942;hpb=7553655597e4e22766b9ed2394896a2a6905fc32 diff --git a/cl_screen.c b/cl_screen.c index 54530042..d6ba9bb8 100644 --- a/cl_screen.c +++ b/cl_screen.c @@ -7,8 +7,10 @@ #include "cl_collision.h" #include "libcurl.h" #include "csprogs.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" @@ -27,20 +29,25 @@ cvar_t scr_conscroll2_x = {CVAR_SAVE, "scr_conscroll2_x", "0", "scroll speed of cvar_t scr_conscroll2_y = {CVAR_SAVE, "scr_conscroll2_y", "0", "scroll speed of gfx/conback2 in y direction"}; cvar_t scr_conscroll3_x = {CVAR_SAVE, "scr_conscroll3_x", "0", "scroll speed of gfx/conback3 in x direction"}; cvar_t scr_conscroll3_y = {CVAR_SAVE, "scr_conscroll3_y", "0", "scroll speed of gfx/conback3 in y direction"}; +#ifdef CONFIG_MENU cvar_t scr_menuforcewhiledisconnected = {0, "scr_menuforcewhiledisconnected", "0", "forces menu while disconnected"}; +#endif cvar_t scr_centertime = {0, "scr_centertime","2", "how long centerprint messages show"}; cvar_t scr_showram = {CVAR_SAVE, "showram","1", "show ram icon if low on surface cache memory (not used)"}; cvar_t scr_showturtle = {CVAR_SAVE, "showturtle","0", "show turtle icon when framerate is too low"}; cvar_t scr_showpause = {CVAR_SAVE, "showpause","1", "show pause icon when game is paused"}; cvar_t scr_showbrand = {0, "showbrand","0", "shows gfx/brand.tga in a corner of the screen (different values select different positions, including centered)"}; cvar_t scr_printspeed = {0, "scr_printspeed","0", "speed of intermission printing (episode end texts), a value of 0 disables the slow printing"}; -cvar_t scr_loadingscreen_background = {0, "scr_loadingscreen_background","0", "show the last visible background during loading screen (costs one screenful of video memory)"}; +cvar_t scr_loadingscreen_background = {0, "scr_loadingscreen_background","1", "show the last visible background during loading screen (costs one screenful of video memory)"}; cvar_t scr_loadingscreen_scale = {0, "scr_loadingscreen_scale","1", "scale factor of the background"}; cvar_t scr_loadingscreen_scale_base = {0, "scr_loadingscreen_scale_base","0", "0 = console pixels, 1 = video pixels"}; cvar_t scr_loadingscreen_scale_limit = {0, "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 = {CVAR_SAVE, "scr_loadingscreen_picture", "gfx/loading", "picture shown during loading"}; cvar_t scr_loadingscreen_count = {0, "scr_loadingscreen_count","1", "number of loading screen files to use randomly (named loading.tga, loading2.tga, loading3.tga, ...)"}; +cvar_t scr_loadingscreen_firstforstartup = {0, "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 = {0, "scr_loadingscreen_barcolor", "0 0 1", "rgb color of loadingscreen progress bar"}; cvar_t scr_loadingscreen_barheight = {0, "scr_loadingscreen_barheight", "8", "the height of the loadingscreen progress bar"}; +cvar_t scr_loadingscreen_maxfps = {0, "scr_loadingscreen_maxfps", "10", "restrict maximal FPS for loading screen so it will not update very often (this will make lesser loading times on a maps loading large number of models)"}; cvar_t scr_infobar_height = {0, "scr_infobar_height", "8", "the height of the infobar items"}; cvar_t vid_conwidth = {CVAR_SAVE, "vid_conwidth", "640", "virtual width of 2D graphics system"}; cvar_t vid_conheight = {CVAR_SAVE, "vid_conheight", "480", "virtual height of 2D graphics system"}; @@ -49,10 +56,12 @@ cvar_t scr_screenshot_jpeg = {CVAR_SAVE, "scr_screenshot_jpeg","1", "save jpeg i cvar_t scr_screenshot_jpeg_quality = {CVAR_SAVE, "scr_screenshot_jpeg_quality","0.9", "image quality of saved jpeg"}; cvar_t scr_screenshot_png = {CVAR_SAVE, "scr_screenshot_png","0", "save png instead of targa"}; cvar_t scr_screenshot_gammaboost = {CVAR_SAVE, "scr_screenshot_gammaboost","1", "gamma correction on saved screenshots and videos, 1.0 saves unmodified images"}; -cvar_t scr_screenshot_hwgamma = {CVAR_SAVE, "scr_screenshot_hwgamma","1", "apply the video gamma ramp to saved screenshots and videos"}; -cvar_t scr_screenshot_alpha = {CVAR_SAVE, "scr_screenshot_alpha","0", "try to write an alpha channel to screenshots (debugging feature)"}; +cvar_t scr_screenshot_alpha = {0, "scr_screenshot_alpha","0", "try to write an alpha channel to screenshots (debugging feature)"}; +cvar_t scr_screenshot_timestamp = {CVAR_SAVE, "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 = {0, "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 = {CVAR_SAVE, "cl_capturevideo_demo_stop", "1", "automatically stops video recording when demo ends"}; cvar_t cl_capturevideo_printfps = {CVAR_SAVE, "cl_capturevideo_printfps", "1", "prints the frames per second captured in capturevideo (is only written to the log file, not to the console, as that would be visible on the video)"}; cvar_t cl_capturevideo_width = {CVAR_SAVE, "cl_capturevideo_width", "0", "scales all frames to this resolution before saving the video"}; cvar_t cl_capturevideo_height = {CVAR_SAVE, "cl_capturevideo_height", "0", "scales all frames to this resolution before saving the video"}; @@ -62,6 +71,7 @@ cvar_t cl_capturevideo_nameformat = {CVAR_SAVE, "cl_capturevideo_nameformat", "d cvar_t cl_capturevideo_number = {CVAR_SAVE, "cl_capturevideo_number", "1", "number to append to video filename, incremented each time a capture begins"}; cvar_t cl_capturevideo_ogg = {CVAR_SAVE, "cl_capturevideo_ogg", "1", "save captured video data as Ogg/Vorbis/Theora streams"}; cvar_t cl_capturevideo_framestep = {CVAR_SAVE, "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 = {0, "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 = {0, "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 = {0, "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)"}; @@ -71,23 +81,39 @@ cvar_t r_stereo_redblue = {0, "r_stereo_redblue", "0", "red/blue anaglyph stereo cvar_t r_stereo_redcyan = {0, "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 = {0, "r_stereo_redgreen", "0", "red/green anaglyph stereo glasses (for those who don't mind yellow)"}; cvar_t r_stereo_angle = {0, "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_zoomwindow = {CVAR_SAVE, "scr_zoomwindow", "0", "displays a zoomed in overlay window"}; -cvar_t scr_zoomwindow_viewsizex = {CVAR_SAVE, "scr_zoomwindow_viewsizex", "20", "horizontal viewsize of zoom window"}; -cvar_t scr_zoomwindow_viewsizey = {CVAR_SAVE, "scr_zoomwindow_viewsizey", "20", "vertical viewsize of zoom window"}; -cvar_t scr_zoomwindow_fov = {CVAR_SAVE, "scr_zoomwindow_fov", "20", "fov of zoom window"}; cvar_t scr_stipple = {0, "scr_stipple", "0", "interlacing-like stippling of the display"}; cvar_t scr_refresh = {0, "scr_refresh", "1", "allows you to completely shut off rendering for benchmarking purposes"}; cvar_t scr_screenshot_name_in_mapdir = {CVAR_SAVE, "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 shownetgraph = {CVAR_SAVE, "shownetgraph", "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 = {0, "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 = {0, "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 = {0, "vid_touchscreen_outlinealpha", "0.25", "opacity of touchscreen area outlines"}; +cvar_t vid_touchscreen_outlinealpha = {0, "vid_touchscreen_outlinealpha", "0", "opacity of touchscreen area outlines"}; cvar_t vid_touchscreen_overlayalpha = {0, "vid_touchscreen_overlayalpha", "0.25", "opacity of touchscreen area icons"}; +cvar_t r_speeds_graph = {CVAR_SAVE, "r_speeds_graph", "0", "display a graph of renderer statistics "}; +cvar_t r_speeds_graph_filter[8] = +{ + {CVAR_SAVE, "r_speeds_graph_filter_r", "timedelta", "Red - display the specified renderer statistic"}, + {CVAR_SAVE, "r_speeds_graph_filter_g", "batch_batches", "Green - display the specified renderer statistic"}, + {CVAR_SAVE, "r_speeds_graph_filter_b", "batch_triangles", "Blue - display the specified renderer statistic"}, + {CVAR_SAVE, "r_speeds_graph_filter_y", "fast_triangles", "Yellow - display the specified renderer statistic"}, + {CVAR_SAVE, "r_speeds_graph_filter_c", "copytriangles_triangles", "Cyan - display the specified renderer statistic"}, + {CVAR_SAVE, "r_speeds_graph_filter_m", "dynamic_triangles", "Magenta - display the specified renderer statistic"}, + {CVAR_SAVE, "r_speeds_graph_filter_w", "animcache_shade_vertices", "White - display the specified renderer statistic"}, + {CVAR_SAVE, "r_speeds_graph_filter_o", "animcache_shape_vertices", "Orange - display the specified renderer statistic"}, +}; +cvar_t r_speeds_graph_length = {CVAR_SAVE, "r_speeds_graph_length", "1024", "number of frames in statistics graph, can be from 4 to 8192"}; +cvar_t r_speeds_graph_seconds = {CVAR_SAVE, "r_speeds_graph_seconds", "2", "number of seconds in graph, can be from 0.1 to 120"}; +cvar_t r_speeds_graph_x = {CVAR_SAVE, "r_speeds_graph_x", "0", "position of graph"}; +cvar_t r_speeds_graph_y = {CVAR_SAVE, "r_speeds_graph_y", "0", "position of graph"}; +cvar_t r_speeds_graph_width = {CVAR_SAVE, "r_speeds_graph_width", "256", "size of graph"}; +cvar_t r_speeds_graph_height = {CVAR_SAVE, "r_speeds_graph_height", "128", "size of graph"}; +cvar_t r_speeds_graph_maxtimedelta = {CVAR_SAVE, "r_speeds_graph_maxtimedelta", "16667", "maximum timedelta to display in the graph (this value will be the top line)"}; +cvar_t r_speeds_graph_maxdefault = {CVAR_SAVE, "r_speeds_graph_maxdefault", "100", "if the minimum and maximum observed values are closer than this, use this value as the graph range (keeps small numbers from being big graphs)"}; + + -extern cvar_t v_glslgamma; extern cvar_t sbar_info_pos; extern cvar_t r_fog_clear; -#define WANT_SCREENSHOT_HWGAMMA (scr_screenshot_hwgamma.integer && vid_usinghwgamma) int jpeg_supported = false; @@ -146,7 +172,7 @@ void SCR_CenterPrint(const char *str) } -void SCR_DrawCenterString (void) +static void SCR_DrawCenterString (void) { char *start; int x, y; @@ -203,7 +229,7 @@ void SCR_DrawCenterString (void) } while (1); } -void SCR_CheckDrawCenterString (void) +static void SCR_CheckDrawCenterString (void) { if (scr_center_lines > scr_erase_lines) scr_erase_lines = scr_center_lines; @@ -223,24 +249,17 @@ void SCR_CheckDrawCenterString (void) SCR_DrawCenterString (); } -void SCR_DrawNetGraph_DrawGraph (int graphx, int graphy, int graphwidth, int graphheight, float graphscale, const char *label, float textsize, int packetcounter, netgraphitem_t *netgraph) +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, numlines; + int j, x, y; int totalbytes = 0; char bytesstring[128]; - float g[NETGRAPH_PACKETS][6]; + float g[NETGRAPH_PACKETS][7]; float *a; float *b; - float vertex3f[(NETGRAPH_PACKETS+2)*5*2*3]; - float color4f[(NETGRAPH_PACKETS+2)*5*2*4]; - float *v; - float *c; DrawQ_Fill(graphx, graphy, graphwidth, graphheight + textsize * 2, 0, 0, 0, 0.5, 0); // draw the bar graph itself - // advance the packet counter because it is the latest packet column being - // built up and should come last - packetcounter = (packetcounter + 1) % NETGRAPH_PACKETS; memset(g, 0, sizeof(g)); for (j = 0;j < NETGRAPH_PACKETS;j++) { @@ -251,12 +270,16 @@ void SCR_DrawNetGraph_DrawGraph (int graphx, int graphy, int graphwidth, int gra 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.96f; + 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; @@ -264,41 +287,29 @@ void SCR_DrawNetGraph_DrawGraph (int graphx, int graphy, int graphwidth, int gra if (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 - numlines = 0; - v = vertex3f; - c = color4f; 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; - VectorSet(v, graphx + graphwidth * a[0], graphy + graphheight * a[2], 0.0f);v += 3;Vector4Set(c, 1.0f, 1.0f, 0.0f, 1.0f);c += 4; - VectorSet(v, graphx + graphwidth * b[0], graphy + graphheight * b[2], 0.0f);v += 3;Vector4Set(c, 1.0f, 1.0f, 0.0f, 1.0f);c += 4; - - VectorSet(v, graphx + graphwidth * a[0], graphy + graphheight * a[1], 0.0f);v += 3;Vector4Set(c, 1.0f, 0.0f, 0.0f, 1.0f);c += 4; - VectorSet(v, graphx + graphwidth * b[0], graphy + graphheight * b[1], 0.0f);v += 3;Vector4Set(c, 1.0f, 0.0f, 0.0f, 1.0f);c += 4; - - VectorSet(v, graphx + graphwidth * a[0], graphy + graphheight * a[5], 0.0f);v += 3;Vector4Set(c, 0.0f, 1.0f, 0.0f, 1.0f);c += 4; - VectorSet(v, graphx + graphwidth * b[0], graphy + graphheight * b[5], 0.0f);v += 3;Vector4Set(c, 0.0f, 1.0f, 0.0f, 1.0f);c += 4; - - VectorSet(v, graphx + graphwidth * a[0], graphy + graphheight * a[4], 0.0f);v += 3;Vector4Set(c, 1.0f, 1.0f, 1.0f, 1.0f);c += 4; - VectorSet(v, graphx + graphwidth * b[0], graphy + graphheight * b[4], 0.0f);v += 3;Vector4Set(c, 1.0f, 1.0f, 1.0f, 1.0f);c += 4; - - VectorSet(v, graphx + graphwidth * a[0], graphy + graphheight * a[3], 0.0f);v += 3;Vector4Set(c, 1.0f, 0.5f, 0.0f, 1.0f);c += 4; - VectorSet(v, graphx + graphwidth * b[0], graphy + graphheight * b[3], 0.0f);v += 3;Vector4Set(c, 1.0f, 0.5f, 0.0f, 1.0f);c += 4; - - numlines += 5; + 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); } - if (numlines > 0) - DrawQ_Lines(0.0f, numlines, vertex3f, color4f, 0); x = graphx; y = graphy + graphheight; dpsnprintf(bytesstring, sizeof(bytesstring), "%i", totalbytes); @@ -311,11 +322,12 @@ void SCR_DrawNetGraph_DrawGraph (int graphx, int graphy, int graphwidth, int gra SCR_DrawNetGraph ============== */ -void SCR_DrawNetGraph (void) +static void SCR_DrawNetGraph (void) { - int i, separator1, separator2, graphwidth, graphheight, netgraph_x, netgraph_y, textsize, index, netgraphsperrow; + 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; @@ -330,6 +342,7 @@ void SCR_DrawNetGraph (void) 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); @@ -338,8 +351,8 @@ void SCR_DrawNetGraph (void) 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, "incoming", textsize, c->incoming_packetcounter, c->incoming_netgraph); - SCR_DrawNetGraph_DrawGraph(netgraph_x + graphwidth + separator1, netgraph_y, graphwidth, graphheight, graphscale, "outgoing", textsize, c->outgoing_packetcounter, c->outgoing_netgraph); + 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 && shownetgraph.integer >= 2) @@ -351,8 +364,8 @@ void SCR_DrawNetGraph (void) 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, va("%s", svs.clients[i].name), textsize, c->outgoing_packetcounter, c->outgoing_netgraph); - SCR_DrawNetGraph_DrawGraph(netgraph_x + graphwidth + separator1, netgraph_y, graphwidth, graphheight, graphscale, "" , textsize, c->incoming_packetcounter, c->incoming_netgraph); + 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++; } } @@ -363,7 +376,7 @@ void SCR_DrawNetGraph (void) SCR_DrawTurtle ============== */ -void SCR_DrawTurtle (void) +static void SCR_DrawTurtle (void) { static int count; @@ -391,7 +404,7 @@ void SCR_DrawTurtle (void) SCR_DrawNet ============== */ -void SCR_DrawNet (void) +static void SCR_DrawNet (void) { if (cls.state != ca_connected) return; @@ -408,7 +421,7 @@ void SCR_DrawNet (void) DrawPause ============== */ -void SCR_DrawPause (void) +static void SCR_DrawPause (void) { cachepic_t *pic; @@ -422,7 +435,7 @@ void SCR_DrawPause (void) return; pic = Draw_CachePic ("gfx/pause"); - DrawQ_Pic ((vid_conwidth.integer - pic->width)/2, (vid_conheight.integer - pic->height)/2, pic, 0, 0, 1, 1, 1, 1, 0); + DrawQ_Pic ((vid_conwidth.integer - Draw_GetPicWidth(pic))/2, (vid_conheight.integer - Draw_GetPicHeight(pic))/2, pic, 0, 0, 1, 1, 1, 1, 0); } /* @@ -430,7 +443,7 @@ void SCR_DrawPause (void) SCR_DrawBrand ============== */ -void SCR_DrawBrand (void) +static void SCR_DrawBrand (void) { cachepic_t *pic; float x, y; @@ -444,26 +457,26 @@ void SCR_DrawBrand (void) { case 1: // bottom left x = 0; - y = vid_conheight.integer - pic->height; + y = vid_conheight.integer - Draw_GetPicHeight(pic); break; case 2: // bottom centre - x = (vid_conwidth.integer - pic->width) / 2; - y = vid_conheight.integer - pic->height; + x = (vid_conwidth.integer - Draw_GetPicWidth(pic)) / 2; + y = vid_conheight.integer - Draw_GetPicHeight(pic); break; case 3: // bottom right - x = vid_conwidth.integer - pic->width; - y = vid_conheight.integer - pic->height; + x = vid_conwidth.integer - Draw_GetPicWidth(pic); + y = vid_conheight.integer - Draw_GetPicHeight(pic); break; case 4: // centre right - x = vid_conwidth.integer - pic->width; - y = (vid_conheight.integer - pic->height) / 2; + x = vid_conwidth.integer - Draw_GetPicWidth(pic); + y = (vid_conheight.integer - Draw_GetPicHeight(pic)) / 2; break; case 5: // top right - x = vid_conwidth.integer - pic->width; + x = vid_conwidth.integer - Draw_GetPicWidth(pic); y = 0; break; case 6: // top centre - x = (vid_conwidth.integer - pic->width) / 2; + x = (vid_conwidth.integer - Draw_GetPicWidth(pic)) / 2; y = 0; break; case 7: // top left @@ -472,7 +485,7 @@ void SCR_DrawBrand (void) break; case 8: // centre left x = 0; - y = (vid_conheight.integer - pic->height) / 2; + y = (vid_conheight.integer - Draw_GetPicHeight(pic)) / 2; break; default: return; @@ -552,9 +565,10 @@ static int SCR_DrawCurlDownload(int offset) float size = scr_infobar_height.value; Curl_downloadinfo_t *downinfo; char temp[256]; + char addinfobuf[128]; const char *addinfo; - downinfo = Curl_GetDownloadInfo(&nDownloads, &addinfo); + downinfo = Curl_GetDownloadInfo(&nDownloads, &addinfo, addinfobuf, sizeof(addinfobuf)); if(!downinfo) return 0; @@ -609,15 +623,16 @@ static int SCR_InfobarHeight(void) 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 += 8; + offset += 1; if(cls.qw_downloadname[0]) - offset += 8; + offset += 1; - downinfo = Curl_GetDownloadInfo(&nDownloads, &addinfo); + downinfo = Curl_GetDownloadInfo(&nDownloads, &addinfo, addinfobuf, sizeof(addinfobuf)); if(downinfo) { offset += (nDownloads + (addinfo ? 1 : 0)); @@ -633,7 +648,7 @@ static int SCR_InfobarHeight(void) SCR_InfoBar_f ============== */ -void SCR_InfoBar_f(void) +static void SCR_InfoBar_f(void) { if(Cmd_Argc() == 3) { @@ -652,14 +667,17 @@ void SCR_InfoBar_f(void) SCR_SetUpToDrawConsole ================== */ -void SCR_SetUpToDrawConsole (void) +static void SCR_SetUpToDrawConsole (void) { // lines of console to display float conlines; +#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) @@ -669,6 +687,7 @@ void SCR_SetUpToDrawConsole (void) } else framecounter = 0; +#endif if (scr_conforcewhiledisconnected.integer && key_dest == key_game && cls.signon != SIGNONS) key_consoleactive |= KEY_CONSOLEACTIVE_FORCED; @@ -709,17 +728,179 @@ SCR_BeginLoadingPlaque ================ */ -void SCR_BeginLoadingPlaque (void) +void SCR_BeginLoadingPlaque (qboolean startup) { // save console log up to this point to log_file if it was set by configs Log_Start(); Host_StartVideo(); - SCR_UpdateLoadingScreen(false); + SCR_UpdateLoadingScreen(false, startup); } //============================================================================= +const char *r_stat_name[r_stat_count] = +{ + "timedelta", + "quality", + "renders", + "entities", + "entities_surfaces", + "entities_triangles", + "world_leafs", + "world_portals", + "world_surfaces", + "world_triangles", + "lightmapupdates", + "lightmapupdatepixels", + "particles", + "drawndecals", + "totaldecals", + "draws", + "draws_vertices", + "draws_elements", + "lights", + "lights_clears", + "lights_scissored", + "lights_lighttriangles", + "lights_shadowtriangles", + "lights_dynamicshadowtriangles", + "bouncegrid_lights", + "bouncegrid_particles", + "bouncegrid_traces", + "bouncegrid_hits", + "bouncegrid_splats", + "bouncegrid_bounces", + "photoncache_animated", + "photoncache_cached", + "photoncache_traced", + "bloom", + "bloom_copypixels", + "bloom_drawpixels", + "rendertargets_used", + "rendertargets_pixels", + "indexbufferuploadcount", + "indexbufferuploadsize", + "vertexbufferuploadcount", + "vertexbufferuploadsize", + "framedatacurrent", + "framedatasize", + "bufferdatacurrent_vertex", // R_BUFFERDATA_ types are added to this index + "bufferdatacurrent_index16", + "bufferdatacurrent_index32", + "bufferdatacurrent_uniform", + "bufferdatasize_vertex", // R_BUFFERDATA_ types are added to this index + "bufferdatasize_index16", + "bufferdatasize_index32", + "bufferdatasize_uniform", + "animcache_skeletal_count", + "animcache_skeletal_bones", + "animcache_skeletal_maxbones", + "animcache_shade_count", + "animcache_shade_vertices", + "animcache_shade_maxvertices", + "animcache_shape_count", + "animcache_shape_vertices", + "animcache_shape_maxvertices", + "batch_batches", + "batch_withgaps", + "batch_surfaces", + "batch_vertices", + "batch_triangles", + "fast_batches", + "fast_surfaces", + "fast_vertices", + "fast_triangles", + "copytriangles_batches", + "copytriangles_surfaces", + "copytriangles_vertices", + "copytriangles_triangles", + "dynamic_batches", + "dynamic_surfaces", + "dynamic_vertices", + "dynamic_triangles", + "dynamicskeletal_batches", + "dynamicskeletal_surfaces", + "dynamicskeletal_vertices", + "dynamicskeletal_triangles", + "dynamic_batches_because_cvar", + "dynamic_surfaces_because_cvar", + "dynamic_vertices_because_cvar", + "dynamic_triangles_because_cvar", + "dynamic_batches_because_lightmapvertex", + "dynamic_surfaces_because_lightmapvertex", + "dynamic_vertices_because_lightmapvertex", + "dynamic_triangles_because_lightmapvertex", + "dynamic_batches_because_deformvertexes_autosprite", + "dynamic_surfaces_because_deformvertexes_autosprite", + "dynamic_vertices_because_deformvertexes_autosprite", + "dynamic_triangles_because_deformvertexes_autosprite", + "dynamic_batches_because_deformvertexes_autosprite2", + "dynamic_surfaces_because_deformvertexes_autosprite2", + "dynamic_vertices_because_deformvertexes_autosprite2", + "dynamic_triangles_because_deformvertexes_autosprite2", + "dynamic_batches_because_deformvertexes_normal", + "dynamic_surfaces_because_deformvertexes_normal", + "dynamic_vertices_because_deformvertexes_normal", + "dynamic_triangles_because_deformvertexes_normal", + "dynamic_batches_because_deformvertexes_wave", + "dynamic_surfaces_because_deformvertexes_wave", + "dynamic_vertices_because_deformvertexes_wave", + "dynamic_triangles_because_deformvertexes_wave", + "dynamic_batches_because_deformvertexes_bulge", + "dynamic_surfaces_because_deformvertexes_bulge", + "dynamic_vertices_because_deformvertexes_bulge", + "dynamic_triangles_because_deformvertexes_bulge", + "dynamic_batches_because_deformvertexes_move", + "dynamic_surfaces_because_deformvertexes_move", + "dynamic_vertices_because_deformvertexes_move", + "dynamic_triangles_because_deformvertexes_move", + "dynamic_batches_because_tcgen_lightmap", + "dynamic_surfaces_because_tcgen_lightmap", + "dynamic_vertices_because_tcgen_lightmap", + "dynamic_triangles_because_tcgen_lightmap", + "dynamic_batches_because_tcgen_vector", + "dynamic_surfaces_because_tcgen_vector", + "dynamic_vertices_because_tcgen_vector", + "dynamic_triangles_because_tcgen_vector", + "dynamic_batches_because_tcgen_environment", + "dynamic_surfaces_because_tcgen_environment", + "dynamic_vertices_because_tcgen_environment", + "dynamic_triangles_because_tcgen_environment", + "dynamic_batches_because_tcmod_turbulent", + "dynamic_surfaces_because_tcmod_turbulent", + "dynamic_vertices_because_tcmod_turbulent", + "dynamic_triangles_because_tcmod_turbulent", + "dynamic_batches_because_nogaps", + "dynamic_surfaces_because_nogaps", + "dynamic_vertices_because_nogaps", + "dynamic_triangles_because_nogaps", + "dynamic_batches_because_derived", + "dynamic_surfaces_because_derived", + "dynamic_vertices_because_derived", + "dynamic_triangles_because_derived", + "entitycache_count", + "entitycache_surfaces", + "entitycache_vertices", + "entitycache_triangles", + "entityanimate_count", + "entityanimate_surfaces", + "entityanimate_vertices", + "entityanimate_triangles", + "entityskeletal_count", + "entityskeletal_surfaces", + "entityskeletal_vertices", + "entityskeletal_triangles", + "entitystatic_count", + "entitystatic_surfaces", + "entitystatic_vertices", + "entitystatic_triangles", + "entitycustom_count", + "entitycustom_surfaces", + "entitycustom_vertices", + "entitycustom_triangles", +}; + char r_speeds_timestring[4096]; int speedstringcount, r_timereport_active; double r_timereport_temp = 0, r_timereport_current = 0, r_timereport_start = 0; @@ -739,11 +920,12 @@ void R_TimeReport(const char *desc) GL_Finish(); CHECKGLERROR r_timereport_temp = r_timereport_current; - r_timereport_current = Sys_DoubleTime(); + r_timereport_current = Sys_DirtyTime(); t = (int) ((r_timereport_current - r_timereport_temp) * 1000000.0 + 0.5); length = dpsnprintf(tempbuf, sizeof(tempbuf), "%8i %s", t, desc); - length = min(length, (int)sizeof(tempbuf) - 1); + if (length < 0) + length = (int)sizeof(tempbuf) - 1; if (r_speeds_longestitem < length) r_speeds_longestitem = length; for (;length < r_speeds_longestitem;length++) @@ -759,17 +941,17 @@ void R_TimeReport(const char *desc) speedstringcount += length; } -void R_TimeReport_BeginFrame(void) +static void R_TimeReport_BeginFrame(void) { speedstringcount = 0; r_speeds_timestring[0] = 0; r_timereport_active = false; memset(&r_refdef.stats, 0, sizeof(r_refdef.stats)); - if (r_speeds.integer >= 2 && cls.signon == SIGNONS && cls.state == ca_connected) + if (r_speeds.integer >= 2) { r_timereport_active = true; - r_timereport_start = r_timereport_current = Sys_DoubleTime(); + r_timereport_start = r_timereport_current = Sys_DirtyTime(); } } @@ -781,63 +963,81 @@ static int R_CountLeafTriangles(const dp_model_t *model, const mleaf_t *leaf) return triangles; } +#define R_SPEEDS_GRAPH_COLORS 8 +#define R_SPEEDS_GRAPH_TEXTLENGTH 64 +static float r_speeds_graph_colors[R_SPEEDS_GRAPH_COLORS][4] = {{1, 0, 0, 1}, {0, 1, 0, 1}, {0, 0, 1, 1}, {1, 1, 0, 1}, {0, 1, 1, 1}, {1, 0, 1, 1}, {1, 1, 1, 1}, {1, 0.5f, 0, 1}}; + extern cvar_t r_viewscale; extern float viewscalefpsadjusted; -void R_TimeReport_EndFrame(void) +static void R_TimeReport_EndFrame(void) { - int i, j, lines, y; + int j, lines; cl_locnode_t *loc; char string[1024+4096]; mleaf_t *viewleaf; + static double oldtime = 0; + + r_refdef.stats[r_stat_timedelta] = (int)((realtime - oldtime) * 1000000.0); + oldtime = realtime; + r_refdef.stats[r_stat_quality] = (int)(100 * r_refdef.view.quality); string[0] = 0; - if (r_speeds.integer && cls.signon == SIGNONS && cls.state == ca_connected) + if (r_speeds.integer) { // put the location name in the r_speeds display as it greatly helps // when creating loc files loc = CL_Locs_FindNearest(cl.movement_origin); viewleaf = (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.PointInLeaf) ? r_refdef.scene.worldmodel->brush.PointInLeaf(r_refdef.scene.worldmodel, r_refdef.view.origin) : NULL; dpsnprintf(string, sizeof(string), -"%6.0fus rendertime %3.0f%% viewscale %s%s\n" +"%6ius time delta %s%s %.3f cl.time%2.4f brightness\n" "%3i renders org:'%+8.2f %+8.2f %+8.2f' dir:'%+2.3f %+2.3f %+2.3f'\n" -"%5i viewleaf%5i cluster%2i area%4i brushes%4i surfaces(%7i triangles)\n" +"%5i viewleaf%5i cluster%3i area%4i brushes%4i surfaces(%7i triangles)\n" "%7i surfaces%7i triangles %5i entities (%7i surfaces%7i triangles)\n" "%5i leafs%5i portals%6i/%6i particles%6i/%6i decals %3i%% quality\n" -"%7i lightmap updates (%7i pixels)%8iKB/%8iKB framedata\n" +"%7i lightmap updates (%7i pixels)%8i/%8i framedata\n" "%4i lights%4i clears%4i scissored%7i light%7i shadow%7i dynamic\n" "bouncegrid:%4i lights%6i particles%6i traces%6i hits%6i splats%6i bounces\n" -"collision cache efficiency:%6i cached%6i traced%6ianimated\n" +"photon cache efficiency:%6i cached%6i traced%6ianimated\n" "%6i draws%8i vertices%8i triangles bloompixels%8i copied%8i drawn\n" +"%3i rendertargets%8i pixels\n" "updated%5i indexbuffers%8i bytes%5i vertexbuffers%8i bytes\n" +"animcache%5ib gpuskeletal%7i vertices (%7i with normals)\n" +"fastbatch%5i count%5i surfaces%7i vertices %7i triangles\n" +"copytris%5i count%5i surfaces%7i vertices %7i triangles\n" +"dynamic%5i count%5i surfaces%7i vertices%7i triangles\n" "%s" -, r_refdef.lastdrawscreentime * 1000000.0, r_viewscale.value * sqrt(viewscalefpsadjusted) * 100.0f, loc ? "Location: " : "", loc ? loc->name : "" -, r_refdef.stats.renders, r_refdef.view.origin[0], r_refdef.view.origin[1], r_refdef.view.origin[2], r_refdef.view.forward[0], r_refdef.view.forward[1], r_refdef.view.forward[2] +, r_refdef.stats[r_stat_timedelta], loc ? "Location: " : "", loc ? loc->name : "", cl.time, r_refdef.view.colorscale +, r_refdef.stats[r_stat_renders], r_refdef.view.origin[0], r_refdef.view.origin[1], r_refdef.view.origin[2], r_refdef.view.forward[0], r_refdef.view.forward[1], r_refdef.view.forward[2] , viewleaf ? (int)(viewleaf - r_refdef.scene.worldmodel->brush.data_leafs) : -1, viewleaf ? viewleaf->clusterindex : -1, viewleaf ? viewleaf->areaindex : -1, viewleaf ? viewleaf->numleafbrushes : 0, viewleaf ? viewleaf->numleafsurfaces : 0, viewleaf ? R_CountLeafTriangles(r_refdef.scene.worldmodel, viewleaf) : 0 -, r_refdef.stats.world_surfaces, r_refdef.stats.world_triangles, r_refdef.stats.entities, r_refdef.stats.entities_surfaces, r_refdef.stats.entities_triangles -, r_refdef.stats.world_leafs, r_refdef.stats.world_portals, r_refdef.stats.particles, cl.num_particles, r_refdef.stats.drawndecals, r_refdef.stats.totaldecals, (int)(100 * r_refdef.view.quality) -, r_refdef.stats.lightmapupdates, r_refdef.stats.lightmapupdatepixels, (r_refdef.stats.framedatacurrent+512) / 1024, (r_refdef.stats.framedatasize+512)/1024 -, r_refdef.stats.lights, r_refdef.stats.lights_clears, r_refdef.stats.lights_scissored, r_refdef.stats.lights_lighttriangles, r_refdef.stats.lights_shadowtriangles, r_refdef.stats.lights_dynamicshadowtriangles -, r_refdef.stats.bouncegrid_lights, r_refdef.stats.bouncegrid_particles, r_refdef.stats.bouncegrid_traces, r_refdef.stats.bouncegrid_hits, r_refdef.stats.bouncegrid_splats, r_refdef.stats.bouncegrid_bounces -, r_refdef.stats.collisioncache_cached, r_refdef.stats.collisioncache_traced, r_refdef.stats.collisioncache_animated -, r_refdef.stats.draws, r_refdef.stats.draws_vertices, r_refdef.stats.draws_elements / 3, r_refdef.stats.bloom_copypixels, r_refdef.stats.bloom_drawpixels -, r_refdef.stats.indexbufferuploadcount, r_refdef.stats.indexbufferuploadsize, r_refdef.stats.vertexbufferuploadcount, r_refdef.stats.vertexbufferuploadsize +, r_refdef.stats[r_stat_world_surfaces], r_refdef.stats[r_stat_world_triangles], r_refdef.stats[r_stat_entities], r_refdef.stats[r_stat_entities_surfaces], r_refdef.stats[r_stat_entities_triangles] +, r_refdef.stats[r_stat_world_leafs], r_refdef.stats[r_stat_world_portals], r_refdef.stats[r_stat_particles], cl.num_particles, r_refdef.stats[r_stat_drawndecals], r_refdef.stats[r_stat_totaldecals], r_refdef.stats[r_stat_quality] +, r_refdef.stats[r_stat_lightmapupdates], r_refdef.stats[r_stat_lightmapupdatepixels], r_refdef.stats[r_stat_framedatacurrent], r_refdef.stats[r_stat_framedatasize] +, r_refdef.stats[r_stat_lights], r_refdef.stats[r_stat_lights_clears], r_refdef.stats[r_stat_lights_scissored], r_refdef.stats[r_stat_lights_lighttriangles], r_refdef.stats[r_stat_lights_shadowtriangles], r_refdef.stats[r_stat_lights_dynamicshadowtriangles] +, r_refdef.stats[r_stat_bouncegrid_lights], r_refdef.stats[r_stat_bouncegrid_particles], r_refdef.stats[r_stat_bouncegrid_traces], r_refdef.stats[r_stat_bouncegrid_hits], r_refdef.stats[r_stat_bouncegrid_splats], r_refdef.stats[r_stat_bouncegrid_bounces] +, r_refdef.stats[r_stat_photoncache_cached], r_refdef.stats[r_stat_photoncache_traced], r_refdef.stats[r_stat_photoncache_animated] +, r_refdef.stats[r_stat_draws], r_refdef.stats[r_stat_draws_vertices], r_refdef.stats[r_stat_draws_elements] / 3, r_refdef.stats[r_stat_bloom_copypixels], r_refdef.stats[r_stat_bloom_drawpixels] +, r_refdef.stats[r_stat_rendertargets_used], r_refdef.stats[r_stat_rendertargets_pixels] +, r_refdef.stats[r_stat_indexbufferuploadcount], r_refdef.stats[r_stat_indexbufferuploadsize], r_refdef.stats[r_stat_vertexbufferuploadcount], r_refdef.stats[r_stat_vertexbufferuploadsize] +, r_refdef.stats[r_stat_animcache_skeletal_bones], r_refdef.stats[r_stat_animcache_shape_vertices], r_refdef.stats[r_stat_animcache_shade_vertices] +, r_refdef.stats[r_stat_batch_fast_batches], r_refdef.stats[r_stat_batch_fast_surfaces], r_refdef.stats[r_stat_batch_fast_vertices], r_refdef.stats[r_stat_batch_fast_triangles] +, r_refdef.stats[r_stat_batch_copytriangles_batches], r_refdef.stats[r_stat_batch_copytriangles_surfaces], r_refdef.stats[r_stat_batch_copytriangles_vertices], r_refdef.stats[r_stat_batch_copytriangles_triangles] +, r_refdef.stats[r_stat_batch_dynamic_batches], r_refdef.stats[r_stat_batch_dynamic_surfaces], r_refdef.stats[r_stat_batch_dynamic_vertices], r_refdef.stats[r_stat_batch_dynamic_triangles] , r_speeds_timestring); + } - memset(&r_refdef.stats, 0, sizeof(r_refdef.stats)); - - speedstringcount = 0; - r_speeds_timestring[0] = 0; - r_timereport_active = false; + speedstringcount = 0; + r_speeds_timestring[0] = 0; + r_timereport_active = false; - if (r_speeds.integer >= 2) - { - r_timereport_active = true; - r_timereport_start = r_timereport_current = Sys_DoubleTime(); - } + if (r_speeds.integer >= 2) + { + r_timereport_active = true; + r_timereport_start = r_timereport_current = Sys_DirtyTime(); } if (string[0]) { + int i, y; if (string[strlen(string)-1] == '\n') string[strlen(string)-1] = 0; lines = 1; @@ -861,6 +1061,176 @@ void R_TimeReport_EndFrame(void) } r_draw2d_force = false; } + + if (r_speeds_graph_length.integer != bound(4, r_speeds_graph_length.integer, 8192)) + Cvar_SetValueQuick(&r_speeds_graph_length, bound(4, r_speeds_graph_length.integer, 8192)); + if (fabs(r_speeds_graph_seconds.value - bound(0.1f, r_speeds_graph_seconds.value, 120.0f)) > 0.01f) + Cvar_SetValueQuick(&r_speeds_graph_seconds, bound(0.1f, r_speeds_graph_seconds.value, 120.0f)); + if (r_speeds_graph.integer) + { + // if we currently have no graph data, reset the graph data entirely + int i; + if (!cls.r_speeds_graph_data) + for (i = 0;i < r_stat_count;i++) + cls.r_speeds_graph_datamin[i] = cls.r_speeds_graph_datamax[i] = 0; + if (cls.r_speeds_graph_length != r_speeds_graph_length.integer) + { + int stat, index, d, graph_length, *graph_data; + cls.r_speeds_graph_length = r_speeds_graph_length.integer; + cls.r_speeds_graph_current = 0; + if (cls.r_speeds_graph_data) + Mem_Free(cls.r_speeds_graph_data); + cls.r_speeds_graph_data = (int *)Mem_Alloc(cls.permanentmempool, cls.r_speeds_graph_length * sizeof(r_refdef.stats)); + // initialize the graph to have the current values throughout history + graph_data = cls.r_speeds_graph_data; + graph_length = cls.r_speeds_graph_length; + index = 0; + for (stat = 0;stat < r_stat_count;stat++) + { + d = r_refdef.stats[stat]; + if (stat == r_stat_timedelta) + d = 0; + for (i = 0;i < graph_length;i++) + graph_data[index++] = d; + } + } + } + else + { + if (cls.r_speeds_graph_length) + { + cls.r_speeds_graph_length = 0; + Mem_Free(cls.r_speeds_graph_data); + cls.r_speeds_graph_data = NULL; + cls.r_speeds_graph_current = 0; + } + } + + if (cls.r_speeds_graph_length) + { + char legend[128]; + int i; + const int *data; + float x, y, width, height, scalex, scaley; + int range_default = max(r_speeds_graph_maxdefault.integer, 1); + int color, stat, stats, index, range_min, range_max; + int graph_current, graph_length, *graph_data; + int statindex[R_SPEEDS_GRAPH_COLORS]; + int sum; + + // add current stats to the graph_data + cls.r_speeds_graph_current++; + if (cls.r_speeds_graph_current >= cls.r_speeds_graph_length) + cls.r_speeds_graph_current = 0; + // poke each new stat into the current offset of its graph + graph_data = cls.r_speeds_graph_data; + graph_current = cls.r_speeds_graph_current; + graph_length = cls.r_speeds_graph_length; + for (stat = 0;stat < r_stat_count;stat++) + graph_data[stat * graph_length + graph_current] = r_refdef.stats[stat]; + + // update the graph ranges + for (stat = 0;stat < r_stat_count;stat++) + { + if (cls.r_speeds_graph_datamin[stat] > r_refdef.stats[stat]) + cls.r_speeds_graph_datamin[stat] = r_refdef.stats[stat]; + if (cls.r_speeds_graph_datamax[stat] < r_refdef.stats[stat]) + cls.r_speeds_graph_datamax[stat] = r_refdef.stats[stat]; + } + + // force 2D drawing to occur even if r_render is 0 + r_draw2d_force = true; + + // position the graph + width = r_speeds_graph_width.value; + height = r_speeds_graph_height.value; + x = bound(0, r_speeds_graph_x.value, vid_conwidth.value - width); + y = bound(0, r_speeds_graph_y.value, vid_conheight.value - height); + + // fill background with a pattern of gray and black at one second intervals + scalex = (float)width / (float)r_speeds_graph_seconds.value; + for (i = 0;i < r_speeds_graph_seconds.integer + 1;i++) + { + float x1 = x + width - (i + 1) * scalex; + float x2 = x + width - i * scalex; + if (x1 < x) + x1 = x; + if (i & 1) + DrawQ_Fill(x1, y, x2 - x1, height, 0.0f, 0.0f, 0.0f, 0.5f, 0); + else + DrawQ_Fill(x1, y, x2 - x1, height, 0.2f, 0.2f, 0.2f, 0.5f, 0); + } + + // count how many stats match our pattern + stats = 0; + color = 0; + for (color = 0;color < R_SPEEDS_GRAPH_COLORS;color++) + { + // look at all stat names and find ones matching the filter + statindex[color] = -1; + if (!r_speeds_graph_filter[color].string) + continue; + for (stat = 0;stat < r_stat_count;stat++) + if (!strcmp(r_stat_name[stat], r_speeds_graph_filter[color].string)) + break; + if (stat >= r_stat_count) + continue; + // record that this color is this stat for the line drawing loop + statindex[color] = stat; + // draw the legend text in the background of the graph + dpsnprintf(legend, sizeof(legend), "%10i :%s", graph_data[stat * graph_length + graph_current], r_stat_name[stat]); + DrawQ_String(x, y + stats * 8, legend, 0, 8, 8, r_speeds_graph_colors[color][0], r_speeds_graph_colors[color][1], r_speeds_graph_colors[color][2], r_speeds_graph_colors[color][3] * 1.00f, 0, NULL, true, FONT_DEFAULT); + // count how many stats we need to graph in vertex buffer + stats++; + } + + if (stats) + { + // legend text is drawn after the graphs + // render the graph lines, we'll go back and render the legend text later + scalex = (float)width / (1000000.0 * r_speeds_graph_seconds.value); + stats = 0; + for (color = 0;color < R_SPEEDS_GRAPH_COLORS;color++) + { + // look at all stat names and find ones matching the filter + stat = statindex[color]; + if (stat < 0) + continue; + // prefer to graph stats with 0 base, but if they are + // negative we have no choice + range_min = cls.r_speeds_graph_datamin[stat]; + range_max = max(cls.r_speeds_graph_datamax[stat], range_min + range_default); + // some stats we specifically override the graph scale on + if (stat == r_stat_timedelta) + range_max = r_speeds_graph_maxtimedelta.integer; + scaley = height / (range_max - range_min); + // generate lines (2 vertices each) + // to deal with incomplete data we walk right to left + data = graph_data + stat * graph_length; + index = graph_current; + sum = 0; + for (i = 0;i < graph_length - 1;) + { + float x1, y1, x2, y2; + x1 = max(x, x + width - sum * scalex); + y1 = y + height - (data[index] - range_min) * scaley; + sum += graph_data[r_stat_timedelta * graph_length + index]; + index--; + if (index < 0) + index = graph_length - 1; + i++; + x2 = max(x, x + width - sum * scalex); + y2 = y + height - (data[index] - range_min) * scaley; + DrawQ_Line(1, x1, y1, x2, y2, r_speeds_graph_colors[color][0], r_speeds_graph_colors[color][1], r_speeds_graph_colors[color][2], r_speeds_graph_colors[color][3], 0); + } + } + } + + // return to not drawing anything if r_render is 0 + r_draw2d_force = false; + } + + memset(&r_refdef.stats, 0, sizeof(r_refdef.stats)); } /* @@ -870,7 +1240,7 @@ SCR_SizeUp_f Keybinding command ================= */ -void SCR_SizeUp_f (void) +static void SCR_SizeUp_f (void) { Cvar_SetValue ("viewsize",scr_viewsize.value+10); } @@ -883,19 +1253,24 @@ SCR_SizeDown_f Keybinding command ================= */ -void SCR_SizeDown_f (void) +static void SCR_SizeDown_f (void) { Cvar_SetValue ("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); @@ -910,14 +1285,19 @@ void CL_Screen_Init(void) Cvar_RegisterVariable (&scr_conscroll3_y); Cvar_RegisterVariable (&scr_conbrightness); Cvar_RegisterVariable (&scr_conforcewhiledisconnected); +#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); @@ -932,10 +1312,12 @@ void CL_Screen_Init(void) Cvar_RegisterVariable (&scr_screenshot_jpeg_quality); Cvar_RegisterVariable (&scr_screenshot_png); Cvar_RegisterVariable (&scr_screenshot_gammaboost); - Cvar_RegisterVariable (&scr_screenshot_hwgamma); 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); @@ -945,6 +1327,7 @@ void CL_Screen_Init(void) 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); @@ -954,10 +1337,6 @@ void CL_Screen_Init(void) Cvar_RegisterVariable(&r_stereo_redcyan); Cvar_RegisterVariable(&r_stereo_redgreen); Cvar_RegisterVariable(&r_stereo_angle); - Cvar_RegisterVariable(&scr_zoomwindow); - Cvar_RegisterVariable(&scr_zoomwindow_viewsizex); - Cvar_RegisterVariable(&scr_zoomwindow_viewsizey); - Cvar_RegisterVariable(&scr_zoomwindow_fov); Cvar_RegisterVariable(&scr_stipple); Cvar_RegisterVariable(&scr_refresh); Cvar_RegisterVariable(&shownetgraph); @@ -965,6 +1344,21 @@ void CL_Screen_Init(void) 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 (COM_CheckParm ("-noconsole")) + Cvar_SetQuick(&scr_conforcewhiledisconnected, "0"); Cmd_AddCommand ("sizeup",SCR_SizeUp_f, "increase view size (increases viewsize cvar)"); Cmd_AddCommand ("sizedown",SCR_SizeDown_f, "decrease view size (decreases viewsize cvar)"); @@ -972,7 +1366,9 @@ void CL_Screen_Init(void) Cmd_AddCommand ("envmap", R_Envmap_f, "render a cubemap (skybox) of the current scene"); Cmd_AddCommand ("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; } @@ -992,6 +1388,7 @@ void SCR_ScreenShot_f (void) unsigned char *buffer2; qboolean jpeg = (scr_screenshot_jpeg.integer != 0); qboolean png = (scr_screenshot_png.integer != 0) && !jpeg; + char vabuf[1024]; if (Cmd_Argc() == 2) { @@ -1019,14 +1416,41 @@ void SCR_ScreenShot_f (void) return; } } + else if (scr_screenshot_timestamp.integer) + { + int shotnumber100; + + // TODO maybe make capturevideo and screenshot use similar name patterns? + 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, Sys_TimeString("%Y%m%d%H%M%S")); + else + dpsnprintf(prefix_name, sizeof(prefix_name), "%s%s", scr_screenshot_name.string, Sys_TimeString("%Y%m%d%H%M%S")); + + // 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? if (scr_screenshot_name_in_mapdir.integer && cl.worldbasename[0]) - dpsnprintf (prefix_name, sizeof(prefix_name), "%s/%s", cl.worldbasename, Sys_TimeString(scr_screenshot_name.string)); + dpsnprintf(prefix_name, sizeof(prefix_name), "%s/%s", cl.worldbasename, Sys_TimeString(scr_screenshot_name.string)); else - dpsnprintf (prefix_name, sizeof(prefix_name), "%s", Sys_TimeString(scr_screenshot_name.string)); + dpsnprintf(prefix_name, sizeof(prefix_name), "%s", Sys_TimeString(scr_screenshot_name.string)); + // 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 ); @@ -1035,15 +1459,19 @@ void SCR_ScreenShot_f (void) // find a file name to save it to for (;shotnumber < 1000000;shotnumber++) - if (!FS_SysFileExists(va("%s/screenshots/%s%06d.tga", fs_gamedir, prefix_name, shotnumber)) && !FS_SysFileExists(va("%s/screenshots/%s%06d.jpg", fs_gamedir, prefix_name, shotnumber)) && !FS_SysFileExists(va("%s/screenshots/%s%06d.png", fs_gamedir, prefix_name, shotnumber))) + if (!FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s%06d.tga", fs_gamedir, prefix_name, shotnumber)) + && !FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s%06d.jpg", fs_gamedir, prefix_name, shotnumber)) + && !FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s%06d.png", fs_gamedir, prefix_name, shotnumber))) break; if (shotnumber >= 1000000) { - Con_Print("Couldn't create the image file\n"); + Con_Print("Couldn't create the image file - you already have 1000000 screenshots!\n"); return; } dpsnprintf(filename, sizeof(filename), "screenshots/%s%06d.%s", prefix_name, shotnumber, jpeg ? "jpg" : png ? "png" : "tga"); + + shotnumber++; } buffer1 = (unsigned char *)Mem_Alloc(tempmempool, vid.width * vid.height * 4); @@ -1066,11 +1494,10 @@ void SCR_ScreenShot_f (void) Mem_Free (buffer1); Mem_Free (buffer2); - - shotnumber++; } -void SCR_CaptureVideo_BeginVideo(void) +#ifdef CONFIG_VIDEO_CAPTURE +static void SCR_CaptureVideo_BeginVideo(void) { double r, g, b; unsigned int i; @@ -1105,7 +1532,7 @@ void SCR_CaptureVideo_BeginVideo(void) cls.capturevideo.soundchannels = S_GetSoundChannels(); cls.capturevideo.startrealtime = realtime; cls.capturevideo.frame = cls.capturevideo.lastfpsframe = 0; - cls.capturevideo.starttime = cls.capturevideo.lastfpstime = Sys_DoubleTime(); + cls.capturevideo.starttime = cls.capturevideo.lastfpstime = realtime; cls.capturevideo.soundsampleframe = 0; cls.capturevideo.realtime = cl_capturevideo_realtime.integer != 0; cls.capturevideo.screenbuffer = (unsigned char *)Mem_Alloc(tempmempool, vid.width * vid.height * 4); @@ -1131,17 +1558,10 @@ Cb = R * -.169 + G * -.332 + B * .500 + 128.; Cr = R * .500 + G * -.419 + B * -.0813 + 128.; */ - if(WANT_SCREENSHOT_HWGAMMA) - { - VID_BuildGammaTables(&cls.capturevideo.vidramp[0], 256); - } - else - { - // identity gamma table - BuildGammaTable16(1.0f, 1.0f, 1.0f, 0.0f, 1.0f, cls.capturevideo.vidramp, 256); - BuildGammaTable16(1.0f, 1.0f, 1.0f, 0.0f, 1.0f, cls.capturevideo.vidramp + 256, 256); - BuildGammaTable16(1.0f, 1.0f, 1.0f, 0.0f, 1.0f, cls.capturevideo.vidramp + 256*2, 256); - } + // identity gamma table + BuildGammaTable16(1.0f, 1.0f, 1.0f, 0.0f, 1.0f, cls.capturevideo.vidramp, 256); + BuildGammaTable16(1.0f, 1.0f, 1.0f, 0.0f, 1.0f, cls.capturevideo.vidramp + 256, 256); + BuildGammaTable16(1.0f, 1.0f, 1.0f, 0.0f, 1.0f, cls.capturevideo.vidramp + 256*2, 256); if(scr_screenshot_gammaboost.value != 1) { double igamma = 1 / scr_screenshot_gammaboost.value; @@ -1263,7 +1683,7 @@ static void SCR_ScaleDownBGRA(unsigned char *in, int inw, int inh, unsigned char } } -void SCR_CaptureVideo_VideoFrame(int newframestepframenum) +static void SCR_CaptureVideo_VideoFrame(int newframestepframenum) { int x = 0, y = 0; int width = cls.capturevideo.width, height = cls.capturevideo.height; @@ -1284,7 +1704,7 @@ void SCR_CaptureVideo_VideoFrame(int newframestepframenum) if(cl_capturevideo_printfps.integer) { char buf[80]; - double t = Sys_DoubleTime(); + double t = realtime; if(t > cls.capturevideo.lastfpstime + 1) { double fps1 = (cls.capturevideo.frame - cls.capturevideo.lastfpsframe) / (t - cls.capturevideo.lastfpstime + 0.0000001); @@ -1299,11 +1719,11 @@ void SCR_CaptureVideo_VideoFrame(int newframestepframenum) void SCR_CaptureVideo_SoundFrame(const portable_sampleframe_t *paintbuffer, size_t length) { - cls.capturevideo.soundsampleframe += length; + cls.capturevideo.soundsampleframe += (int)length; cls.capturevideo.soundframe(paintbuffer, length); } -void SCR_CaptureVideo(void) +static void SCR_CaptureVideo(void) { int newframenum; if (cl_capturevideo.integer) @@ -1346,6 +1766,7 @@ void SCR_CaptureVideo(void) else if (cls.capturevideo.active) SCR_CaptureVideo_EndVideo(); } +#endif /* =============== @@ -1383,6 +1804,7 @@ static void R_Envmap_f (void) char filename[MAX_QPATH], basename[MAX_QPATH]; unsigned char *buffer1; unsigned char *buffer2; + r_rendertarget_t *rt; if (Cmd_Argc() != 3) { @@ -1415,13 +1837,19 @@ static void R_Envmap_f (void) r_refdef.view.depth = 1; r_refdef.view.useperspective = true; r_refdef.view.isoverlay = false; + r_refdef.view.ismain = true; r_refdef.view.frustum_x = 1; // tan(45 * M_PI / 180.0); r_refdef.view.frustum_y = 1; // tan(45 * M_PI / 180.0); + r_refdef.view.ortho_x = 90; // abused as angle by VM_CL_R_SetView + r_refdef.view.ortho_y = 90; // abused as angle by VM_CL_R_SetView buffer1 = (unsigned char *)Mem_Alloc(tempmempool, size * size * 4); buffer2 = (unsigned char *)Mem_Alloc(tempmempool, size * size * 3); + // TODO: use TEXTYPE_COLORBUFFER16F and output to .exr files as well? + rt = R_RenderTarget_Get(size, size, TEXTYPE_DEPTHBUFFER24STENCIL8, true, TEXTYPE_COLORBUFFER, TEXTYPE_UNUSED, TEXTYPE_UNUSED, TEXTYPE_UNUSED); + CL_UpdateEntityShading(); for (j = 0;j < 12;j++) { dpsnprintf(filename, sizeof(filename), "env/%s%s.tga", basename, envmapinfo[j].name); @@ -1429,7 +1857,7 @@ static void R_Envmap_f (void) r_refdef.view.quality = 1; r_refdef.view.clear = true; R_Mesh_Start(); - R_RenderView(); + R_RenderView(rt->fbo, rt->depthtexture, rt->colortexture[0], 0, 0, size, size); R_Mesh_Finish(); SCR_ScreenShot(filename, buffer1, buffer2, 0, vid.height - (r_refdef.view.y + r_refdef.view.height), size, size, envmapinfo[j].flipx, envmapinfo[j].flipy, envmapinfo[j].flipdiagonaly, false, false, false, false); } @@ -1446,7 +1874,7 @@ void SHOWLMP_decodehide(void) { int i; char *lmplabel; - lmplabel = MSG_ReadString(); + lmplabel = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)); for (i = 0;i < cl.num_showlmps;i++) if (cl.showlmps[i].isactive && strcmp(cl.showlmps[i].label, lmplabel) == 0) { @@ -1460,27 +1888,29 @@ void SHOWLMP_decodeshow(void) int k; char lmplabel[256], picname[256]; float x, y; - strlcpy (lmplabel,MSG_ReadString(), sizeof (lmplabel)); - strlcpy (picname, MSG_ReadString(), sizeof (picname)); + strlcpy (lmplabel,MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof (lmplabel)); + strlcpy (picname, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof (picname)); if (gamemode == GAME_NEHAHRA) // LordHavoc: nasty old legacy junk { - x = MSG_ReadByte(); - y = MSG_ReadByte(); + x = MSG_ReadByte(&cl_message); + y = MSG_ReadByte(&cl_message); } else { - x = MSG_ReadShort(); - y = MSG_ReadShort(); + x = MSG_ReadShort(&cl_message); + y = MSG_ReadShort(&cl_message); } if (!cl.showlmps || cl.num_showlmps >= cl.max_showlmps) { showlmp_t *oldshowlmps = cl.showlmps; cl.max_showlmps += 16; cl.showlmps = (showlmp_t *) Mem_Alloc(cls.levelmempool, cl.max_showlmps * sizeof(showlmp_t)); - if (cl.num_showlmps) - memcpy(cl.showlmps, oldshowlmps, cl.num_showlmps * sizeof(showlmp_t)); if (oldshowlmps) + { + if (cl.num_showlmps) + memcpy(cl.showlmps, oldshowlmps, cl.num_showlmps * sizeof(showlmp_t)); Mem_Free(oldshowlmps); + } } for (k = 0;k < cl.max_showlmps;k++) if (cl.showlmps[k].isactive && !strcmp(cl.showlmps[k].label, lmplabel)) @@ -1522,22 +1952,15 @@ qboolean SCR_ScreenShot(char *filename, unsigned char *buffer1, unsigned char *b GL_ReadPixelsBGRA(x, y, width, height, buffer1); - if(gammacorrect && (scr_screenshot_gammaboost.value != 1 || WANT_SCREENSHOT_HWGAMMA)) + if(gammacorrect && (scr_screenshot_gammaboost.value != 1)) { int i; double igamma = 1.0 / scr_screenshot_gammaboost.value; unsigned short vidramp[256 * 3]; - if(WANT_SCREENSHOT_HWGAMMA) - { - VID_BuildGammaTables(&vidramp[0], 256); - } - else - { - // identity gamma table - BuildGammaTable16(1.0f, 1.0f, 1.0f, 0.0f, 1.0f, vidramp, 256); - BuildGammaTable16(1.0f, 1.0f, 1.0f, 0.0f, 1.0f, vidramp + 256, 256); - BuildGammaTable16(1.0f, 1.0f, 1.0f, 0.0f, 1.0f, vidramp + 256*2, 256); - } + // identity gamma table + BuildGammaTable16(1.0f, 1.0f, 1.0f, 0.0f, 1.0f, vidramp, 256); + BuildGammaTable16(1.0f, 1.0f, 1.0f, 0.0f, 1.0f, vidramp + 256, 256); + BuildGammaTable16(1.0f, 1.0f, 1.0f, 0.0f, 1.0f, vidramp + 256*2, 256); if(scr_screenshot_gammaboost.value != 1) { for (i = 0;i < 256 * 3;i++) @@ -1584,7 +2007,7 @@ qboolean SCR_ScreenShot(char *filename, unsigned char *buffer1, unsigned char *b //============================================================================= int scr_numtouchscreenareas; -scr_touchscreenarea_t scr_touchscreenareas[16]; +scr_touchscreenarea_t scr_touchscreenareas[128]; static void SCR_DrawTouchscreenOverlay(void) { @@ -1602,40 +2025,41 @@ static void SCR_DrawTouchscreenOverlay(void) DrawQ_Fill(a->rect[0] + 1, a->rect[1] + a->rect[3] - 2, a->rect[2] - 2, 1 , 1, 1, 1, vid_touchscreen_outlinealpha.value * (0.5f + 0.5f * a->active), 0); DrawQ_Fill(a->rect[0] + 2, a->rect[1] + a->rect[3] - 1, a->rect[2] - 4, 1 , 1, 1, 1, vid_touchscreen_outlinealpha.value * (0.5f + 0.5f * a->active), 0); } - pic = a->pic ? Draw_CachePic(a->pic) : NULL; - if (pic && pic->tex != r_texture_notexture) - DrawQ_Pic(a->rect[0], a->rect[1], Draw_CachePic(a->pic), a->rect[2], a->rect[3], 1, 1, 1, vid_touchscreen_overlayalpha.value * (0.5f + 0.5f * a->active), 0); + pic = a->pic ? Draw_CachePic_Flags(a->pic, CACHEPICFLAG_FAILONMISSING) : NULL; + if (Draw_IsPicLoaded(pic)) + DrawQ_Pic(a->rect[0], a->rect[1], pic, a->rect[2], a->rect[3], 1, 1, 1, vid_touchscreen_overlayalpha.value * (0.5f + 0.5f * a->active), 0); + if (a->text && a->text[0]) + { + int textwidth = DrawQ_TextWidth(a->text, 0, a->textheight, a->textheight, false, FONT_CHAT); + DrawQ_String(a->rect[0] + (a->rect[2] - textwidth) * 0.5f, a->rect[1] + (a->rect[3] - a->textheight) * 0.5f, a->text, 0, a->textheight, a->textheight, 1.0f, 1.0f, 1.0f, vid_touchscreen_overlayalpha.value, 0, NULL, false, FONT_CHAT); + } } } -extern void R_UpdateFogColor(void); void R_ClearScreen(qboolean fogcolor) { float clearcolor[4]; - // clear to black - Vector4Clear(clearcolor); - if (fogcolor) + if (scr_screenshot_alpha.integer) + // clear to transparency (so png screenshots can contain alpha channel, useful for building model pictures) + Vector4Set(clearcolor, 0.0f, 0.0f, 0.0f, 0.0f); + else + // clear to opaque black (if we're being composited it might otherwise render as transparent) + Vector4Set(clearcolor, 0.0f, 0.0f, 0.0f, 1.0f); + if (fogcolor && r_fog_clear.integer) { - R_UpdateFogColor(); - if (r_fog_clear.integer) - VectorCopy(r_refdef.fogcolor, clearcolor); + R_UpdateFog(); + VectorCopy(r_refdef.fogcolor, clearcolor); } // clear depth is 1.0 - // LordHavoc: we use a stencil centered around 128 instead of 0, - // to avoid clamping interfering with strange shadow volume - // drawing orders // clear the screen - GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | (vid.stencil ? GL_STENCIL_BUFFER_BIT : 0), clearcolor, 1.0f, 128); + GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | (vid.stencil ? GL_STENCIL_BUFFER_BIT : 0), clearcolor, 1.0f, 0); } -qboolean CL_VM_UpdateView (void); -void SCR_DrawConsole (void); -void R_Shadow_EditLights_DrawSelectedLightProperties(void); - int r_stereo_side; +extern cvar_t v_isometric; +extern cvar_t v_isometric_verticalfov; -extern void Sbar_ShowFPS(void); -void SCR_DrawScreen (void) +static void SCR_DrawScreen (void) { Draw_Frame(); @@ -1643,6 +2067,10 @@ void SCR_DrawScreen (void) R_UpdateVariables(); + // this will be set back to 0 by R_RenderView during CL_VM_UpdateView + r_refdef.draw2dstage = 1; + R_ResetViewRendering2D_Common(0, NULL, NULL, 0, 0, vid.width, vid.height, vid_conwidth.integer, vid_conheight.integer); + // Quake uses clockwise winding, so these are swapped r_refdef.view.cullface_front = GL_BACK; r_refdef.view.cullface_back = GL_FRONT; @@ -1704,38 +2132,30 @@ void SCR_DrawScreen (void) // for a 4x3 display, if the ratio is not 4x3 this makes the fov // higher/lower according to the ratio r_refdef.view.useperspective = true; - r_refdef.view.frustum_y = tan(scr_fov.value * M_PI / 360.0) * (3.0/4.0) * cl.viewzoom; + r_refdef.view.frustum_y = tan(scr_fov.value * M_PI / 360.0) * (3.0 / 4.0) * cl.viewzoom; r_refdef.view.frustum_x = r_refdef.view.frustum_y * (float)r_refdef.view.width / (float)r_refdef.view.height / vid_pixelheight.value; r_refdef.view.frustum_x *= r_refdef.frustumscale_x; r_refdef.view.frustum_y *= r_refdef.frustumscale_y; + r_refdef.view.ortho_x = atan(r_refdef.view.frustum_x) * (360.0 / M_PI); // abused as angle by VM_CL_R_SetView + r_refdef.view.ortho_y = atan(r_refdef.view.frustum_y) * (360.0 / M_PI); // abused as angle by VM_CL_R_SetView - if(!CL_VM_UpdateView()) - R_RenderView(); + r_refdef.view.ismain = true; - if (scr_zoomwindow.integer) + // if CSQC is loaded, it is required to provide the CSQC_UpdateView function, + // and won't render a view if it does not call that. + if (cl.csqc_loaded) + CL_VM_UpdateView(r_stereo_side ? 0.0 : max(0.0, cl.time - cl.oldtime)); + else { - float sizex = bound(10, scr_zoomwindow_viewsizex.value, 100) / 100.0; - float sizey = bound(10, scr_zoomwindow_viewsizey.value, 100) / 100.0; - r_refdef.view.width = (int)(vid.width * sizex); - r_refdef.view.height = (int)(vid.height * sizey); - r_refdef.view.depth = 1; - r_refdef.view.x = (int)((vid.width - r_refdef.view.width)/2); - r_refdef.view.y = 0; - r_refdef.view.z = 0; - - r_refdef.view.useperspective = true; - r_refdef.view.frustum_y = tan(scr_zoomwindow_fov.value * M_PI / 360.0) * (3.0/4.0) * cl.viewzoom; - r_refdef.view.frustum_x = r_refdef.view.frustum_y * vid_pixelheight.value * (float)r_refdef.view.width / (float)r_refdef.view.height; - - r_refdef.view.frustum_x *= r_refdef.frustumscale_x; - r_refdef.view.frustum_y *= r_refdef.frustumscale_y; - - if(!CL_VM_UpdateView()) - R_RenderView(); + CL_UpdateEntityShading(); + R_RenderView(0, NULL, NULL, r_refdef.view.x, r_refdef.view.y, r_refdef.view.width, r_refdef.view.height); } } + // Don't apply debugging stuff like r_showsurfaces to the UI + r_refdef.view.showdebug = false; + if (!r_stereo_sidebyside.integer && !r_stereo_horizontal.integer && !r_stereo_vertical.integer) { r_refdef.view.width = vid.width; @@ -1791,12 +2211,13 @@ void SCR_DrawScreen (void) SCR_DrawPause (); if (!r_letterbox.value) Sbar_Draw(); - Sbar_ShowFPS(); SHOWLMP_drawall(); SCR_CheckDrawCenterString(); } SCR_DrawNetGraph (); +#ifdef CONFIG_MENU MR_Draw(); +#endif CL_DrawVideo(); R_Shadow_EditLights_DrawSelectedLightProperties(); @@ -1811,17 +2232,14 @@ void SCR_DrawScreen (void) if (r_timereport_active) R_TimeReport("2d"); - if (cls.signon == SIGNONS) - { - R_TimeReport_EndFrame(); - R_TimeReport_BeginFrame(); - } + R_TimeReport_EndFrame(); + R_TimeReport_BeginFrame(); + Sbar_ShowFPS(); DrawQ_Finish(); - R_DrawGamma(); - R_Mesh_Finish(); + R_RenderTarget_FreeUnused(false); } typedef struct loadingscreenstack_s @@ -1858,17 +2276,8 @@ static void SCR_SetLoadingScreenTexture(void) SCR_ClearLoadingScreenTexture(); - if (vid.support.arb_texture_non_power_of_two) - { - w = vid.width; h = vid.height; - loadingscreentexture_w = loadingscreentexture_h = 1; - } - else - { - w = CeilPowerOf2(vid.width); h = CeilPowerOf2(vid.height); - loadingscreentexture_w = vid.width / (float) w; - loadingscreentexture_h = vid.height / (float) h; - } + w = vid.width; h = vid.height; + loadingscreentexture_w = loadingscreentexture_h = 1; loadingscreentexture = R_LoadTexture2D(r_main_texturepool, "loadingscreentexture", w, h, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCENEAREST | TEXF_CLAMP, -1, NULL); R_Mesh_CopyToTexture(loadingscreentexture, 0, 0, 0, 0, vid.width, vid.height); @@ -1887,7 +2296,7 @@ static void SCR_SetLoadingScreenTexture(void) void SCR_UpdateLoadingScreenIfShown(void) { if(loadingscreendone) - SCR_UpdateLoadingScreen(loadingscreencleared); + SCR_UpdateLoadingScreen(loadingscreencleared, false); } void SCR_PushLoadingScreen (qboolean redraw, const char *msg, float len_in_parent) @@ -2009,7 +2418,7 @@ static void SCR_DrawLoadingStack(void) sscanf(scr_loadingscreen_barcolor.string, "%f %f %f", &colors[12], &colors[13], &colors[14]); colors[15] = 1; R_Mesh_PrepareVertices_Generic_Arrays(4, verts, colors, NULL); - R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1); + R_SetupShader_Generic_NoTexture(true, true); R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0); // make sure everything is cleared, including the progress indicator @@ -2026,13 +2435,14 @@ static void SCR_DrawLoadingScreen_SharedSetup (qboolean clear) { r_viewport_t viewport; float x, y, w, h, sw, sh, f; + char vabuf[1024]; // release mouse grab while loading if (!vid.fullscreen) VID_SetMouse(false, false, false); // CHECKGLERROR r_refdef.draw2dstage = true; R_Viewport_InitOrtho(&viewport, &identitymatrix, 0, 0, vid.width, vid.height, 0, 0, vid_conwidth.integer, vid_conheight.integer, -10, 100, NULL); - R_Mesh_ResetRenderTargets(); + R_Mesh_SetRenderTargets(0, NULL, NULL, NULL, NULL, NULL); R_SetViewport(&viewport); GL_ColorMask(1,1,1,1); // when starting up a new video mode, make sure the screen is cleared to black @@ -2042,10 +2452,10 @@ static void SCR_DrawLoadingScreen_SharedSetup (qboolean clear) R_Mesh_Start(); R_EntityMatrix(&identitymatrix); // draw the loading plaque - loadingscreenpic = Draw_CachePic (loadingscreenpic_number ? va("gfx/loading%d", loadingscreenpic_number+1) : "gfx/loading"); + loadingscreenpic = Draw_CachePic_Flags (loadingscreenpic_number ? va(vabuf, sizeof(vabuf), "%s%d", scr_loadingscreen_picture.string, loadingscreenpic_number+1) : scr_loadingscreen_picture.string, loadingscreenpic_number ? CACHEPICFLAG_NOTPERSISTENT : 0); - w = loadingscreenpic->width; - h = loadingscreenpic->height; + w = Draw_GetPicWidth(loadingscreenpic); + h = Draw_GetPicHeight(loadingscreenpic); // apply scale w *= scr_loadingscreen_scale.value; @@ -2108,11 +2518,11 @@ static void SCR_DrawLoadingScreen (qboolean clear) if(loadingscreentexture) { R_Mesh_PrepareVertices_Generic_Arrays(4, loadingscreentexture_vertex3f, NULL, loadingscreentexture_texcoord2f); - R_SetupShader_Generic(loadingscreentexture, NULL, GL_MODULATE, 1); + R_SetupShader_Generic(loadingscreentexture, false, true, true); R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0); } R_Mesh_PrepareVertices_Generic_Arrays(4, loadingscreenpic_vertex3f, NULL, loadingscreenpic_texcoord2f); - R_SetupShader_Generic(loadingscreenpic->tex, NULL, GL_MODULATE, 1); + R_SetupShader_Generic(Draw_GetPicTexture(loadingscreenpic), true, true, false); R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0); SCR_DrawLoadingStack(); } @@ -2124,7 +2534,9 @@ static void SCR_DrawLoadingScreen_SharedFinish (qboolean clear) VID_Finish(); } -void SCR_UpdateLoadingScreen (qboolean clear) +static double loadingscreen_lastupdate; + +void SCR_UpdateLoadingScreen (qboolean clear, qboolean startup) { keydest_t old_key_dest; int old_key_consoleactive; @@ -2133,6 +2545,19 @@ void SCR_UpdateLoadingScreen (qboolean clear) if (vid_hidden || cls.state == ca_dedicated) return; + // limit update rate + if (scr_loadingscreen_maxfps.value) + { + double t = Sys_DirtyTime(); + if ((t - loadingscreen_lastupdate) < 1.0f/scr_loadingscreen_maxfps.value) + return; + loadingscreen_lastupdate = t; + } + + // set up the r_texture_gammaramps texture which we need for rendering the loadingscreenpic + VID_UpdateGamma(); + R_UpdateVariables(); + if(!scr_loadingscreen_background.integer) clear = true; @@ -2140,7 +2565,17 @@ void SCR_UpdateLoadingScreen (qboolean clear) clear |= loadingscreencleared; if(!loadingscreendone) - loadingscreenpic_number = rand() % (scr_loadingscreen_count.integer > 1 ? scr_loadingscreen_count.integer : 1); + { + if(startup && scr_loadingscreen_firstforstartup.integer) + loadingscreenpic_number = 0; + else if(scr_loadingscreen_firstforstartup.integer) + if(scr_loadingscreen_count.integer > 1) + loadingscreenpic_number = rand() % (scr_loadingscreen_count.integer - 1) + 1; + else + loadingscreenpic_number = 0; + else + loadingscreenpic_number = rand() % (scr_loadingscreen_count.integer > 1 ? scr_loadingscreen_count.integer : 1); + } if(clear) SCR_ClearLoadingScreenTexture(); @@ -2154,8 +2589,11 @@ void SCR_UpdateLoadingScreen (qboolean clear) } loadingscreencleared = clear; - if (qglDrawBuffer) - qglDrawBuffer(GL_BACK); +#ifdef USE_GLES2 + SCR_DrawLoadingScreen_SharedSetup(clear); + SCR_DrawLoadingScreen(clear); +#else + qglDrawBuffer(GL_BACK); SCR_DrawLoadingScreen_SharedSetup(clear); if (vid.stereobuffer) { @@ -2166,10 +2604,10 @@ void SCR_UpdateLoadingScreen (qboolean clear) } else { - if (qglDrawBuffer) - qglDrawBuffer(GL_BACK); + qglDrawBuffer(GL_BACK); SCR_DrawLoadingScreen(clear); } +#endif SCR_DrawLoadingScreen_SharedFinish(clear); // this goes into the event loop, and should prevent unresponsive cursor on vista @@ -2196,21 +2634,90 @@ extern cvar_t cl_minfps; extern cvar_t cl_minfps_fade; extern cvar_t cl_minfps_qualitymax; extern cvar_t cl_minfps_qualitymin; -extern cvar_t cl_minfps_qualitypower; -extern cvar_t cl_minfps_qualityscale; -extern cvar_t r_viewscale_fpsscaling; -static double cl_updatescreen_rendertime = 0; +extern cvar_t cl_minfps_qualitymultiply; +extern cvar_t cl_minfps_qualityhysteresis; +extern cvar_t cl_minfps_qualitystepmax; +extern cvar_t cl_minfps_force; static double cl_updatescreen_quality = 1; -extern void Sbar_ShowFPS_Update(void); void CL_UpdateScreen(void) { vec3_t vieworigin; - double rendertime1; - double drawscreenstart; + static double drawscreenstart = 0.0; + double drawscreendelta; float conwidth, conheight; - float f; r_viewport_t viewport; + if(drawscreenstart) + { + drawscreendelta = Sys_DirtyTime() - drawscreenstart; + if (cl_minfps.value > 0 && (cl_minfps_force.integer || !(cls.timedemo || (cls.capturevideo.active && !cls.capturevideo.realtime))) && drawscreendelta >= 0 && drawscreendelta < 60) + { + // quality adjustment according to render time + double actualframetime; + double targetframetime; + double adjust; + double f; + double h; + + // fade lastdrawscreentime + r_refdef.lastdrawscreentime += (drawscreendelta - r_refdef.lastdrawscreentime) * cl_minfps_fade.value; + + // find actual and target frame times + actualframetime = r_refdef.lastdrawscreentime; + targetframetime = (1.0 / cl_minfps.value); + + // we scale hysteresis by quality + h = cl_updatescreen_quality * cl_minfps_qualityhysteresis.value; + + // calculate adjustment assuming linearity + f = cl_updatescreen_quality / actualframetime * cl_minfps_qualitymultiply.value; + adjust = (targetframetime - actualframetime) * f; + + // one sided hysteresis + if(adjust > 0) + adjust = max(0, adjust - h); + + // adjust > 0 if: + // (targetframetime - actualframetime) * f > h + // ((1.0 / cl_minfps.value) - actualframetime) * (cl_updatescreen_quality / actualframetime * cl_minfps_qualitymultiply.value) > (cl_updatescreen_quality * cl_minfps_qualityhysteresis.value) + // ((1.0 / cl_minfps.value) - actualframetime) * (cl_minfps_qualitymultiply.value / actualframetime) > cl_minfps_qualityhysteresis.value + // (1.0 / cl_minfps.value) * (cl_minfps_qualitymultiply.value / actualframetime) - cl_minfps_qualitymultiply.value > cl_minfps_qualityhysteresis.value + // (1.0 / cl_minfps.value) * (cl_minfps_qualitymultiply.value / actualframetime) > cl_minfps_qualityhysteresis.value + cl_minfps_qualitymultiply.value + // (1.0 / cl_minfps.value) / actualframetime > (cl_minfps_qualityhysteresis.value + cl_minfps_qualitymultiply.value) / cl_minfps_qualitymultiply.value + // (1.0 / cl_minfps.value) / actualframetime > 1.0 + cl_minfps_qualityhysteresis.value / cl_minfps_qualitymultiply.value + // cl_minfps.value * actualframetime < 1.0 / (1.0 + cl_minfps_qualityhysteresis.value / cl_minfps_qualitymultiply.value) + // actualframetime < 1.0 / cl_minfps.value / (1.0 + cl_minfps_qualityhysteresis.value / cl_minfps_qualitymultiply.value) + // actualfps > cl_minfps.value * (1.0 + cl_minfps_qualityhysteresis.value / cl_minfps_qualitymultiply.value) + + // adjust < 0 if: + // (targetframetime - actualframetime) * f < 0 + // ((1.0 / cl_minfps.value) - actualframetime) * (cl_updatescreen_quality / actualframetime * cl_minfps_qualitymultiply.value) < 0 + // ((1.0 / cl_minfps.value) - actualframetime) < 0 + // -actualframetime) < -(1.0 / cl_minfps.value) + // actualfps < cl_minfps.value + + /* + Con_Printf("adjust UP if fps > %f, adjust DOWN if fps < %f\n", + cl_minfps.value * (1.0 + cl_minfps_qualityhysteresis.value / cl_minfps_qualitymultiply.value), + cl_minfps.value); + */ + + // don't adjust too much at once + adjust = bound(-cl_minfps_qualitystepmax.value, adjust, cl_minfps_qualitystepmax.value); + + // adjust! + cl_updatescreen_quality += adjust; + cl_updatescreen_quality = bound(max(0.01, cl_minfps_qualitymin.value), cl_updatescreen_quality, cl_minfps_qualitymax.value); + } + else + { + cl_updatescreen_quality = 1; + r_refdef.lastdrawscreentime = 0; + } + } + + drawscreenstart = Sys_DirtyTime(); + Sbar_ShowFPS_Update(); if (!scr_initialized || !con_initialized || !scr_refresh.integer) @@ -2218,7 +2725,7 @@ void CL_UpdateScreen(void) loadingscreendone = false; - if(gamemode == GAME_NEXUIZ || gamemode == GAME_XONOTIC) + if(IS_NEXUIZ_DERIVED(gamemode)) { // play a bit with the palette (experimental) palette_rgb_pantscolormap[15][0] = (unsigned char) (128 + 127 * sin(cl.time / exp(1.0f) + 0.0f*M_PI/3.0f)); @@ -2237,8 +2744,6 @@ void CL_UpdateScreen(void) return; } - rendertime1 = Sys_DoubleTime(); - conwidth = bound(160, vid_conwidth.value, 32768); conheight = bound(90, vid_conheight.value, 24576); if (vid_conwidth.value != conwidth) @@ -2271,6 +2776,9 @@ void CL_UpdateScreen(void) sb_lines = 24+16+8; } + R_FrameData_NewFrame(); + R_BufferData_NewFrame(); + Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, vieworigin); R_HDR_UpdateIrisAdaptation(vieworigin); @@ -2280,23 +2788,13 @@ void CL_UpdateScreen(void) SCR_SetUpToDrawConsole(); - if (qglDrawBuffer) - { - CHECKGLERROR - qglDrawBuffer(GL_BACK);CHECKGLERROR - // set dithering mode - if (gl_dither.integer) - { - qglEnable(GL_DITHER);CHECKGLERROR - } - else - { - qglDisable(GL_DITHER);CHECKGLERROR - } - } +#ifndef USE_GLES2 + CHECKGLERROR + qglDrawBuffer(GL_BACK);CHECKGLERROR +#endif R_Viewport_InitOrtho(&viewport, &identitymatrix, 0, 0, vid.width, vid.height, 0, 0, vid_conwidth.integer, vid_conheight.integer, -10, 100, NULL); - R_Mesh_ResetRenderTargets(); + R_Mesh_SetRenderTargets(0, NULL, NULL, NULL, NULL, NULL); R_SetViewport(&viewport); GL_ScissorTest(false); GL_ColorMask(1,1,1,1); @@ -2305,39 +2803,17 @@ void CL_UpdateScreen(void) R_ClearScreen(false); r_refdef.view.clear = false; r_refdef.view.isoverlay = false; - f = pow((float)cl_updatescreen_quality, cl_minfps_qualitypower.value) * cl_minfps_qualityscale.value; - r_refdef.view.quality = bound(cl_minfps_qualitymin.value, f, cl_minfps_qualitymax.value); - if (qglPolygonStipple) + // calculate r_refdef.view.quality + r_refdef.view.quality = cl_updatescreen_quality; + + if(scr_stipple.integer) { - if(scr_stipple.integer) - { - GLubyte stipple[128]; - int i, s, width, parts; - static int frame = 0; - ++frame; - - s = scr_stipple.integer; - parts = (s & 007); - width = (s & 070) >> 3; - - qglEnable(GL_POLYGON_STIPPLE);CHECKGLERROR // 0x0B42 - for(i = 0; i < 128; ++i) - { - int line = i/4; - stipple[i] = (((line >> width) + frame) & ((1 << parts) - 1)) ? 0x00 : 0xFF; - } - qglPolygonStipple(stipple);CHECKGLERROR - } - else - { - qglDisable(GL_POLYGON_STIPPLE);CHECKGLERROR - } + Con_Print("FIXME: scr_stipple not implemented\n"); + Cvar_SetValueQuick(&scr_stipple, 0); } - if (r_viewscale_fpsscaling.integer) - GL_Finish(); - drawscreenstart = Sys_DoubleTime(); +#ifndef USE_GLES2 if (R_Stereo_Active()) { r_stereo_side = 0; @@ -2355,6 +2831,7 @@ void CL_UpdateScreen(void) SCR_DrawScreen(); r_stereo_side = 1; + r_refdef.view.clear = true; if (r_stereo_redblue.integer || r_stereo_redgreen.integer || r_stereo_redcyan.integer) { @@ -2367,24 +2844,20 @@ void CL_UpdateScreen(void) qglDrawBuffer(GL_BACK_LEFT); SCR_DrawScreen(); + r_stereo_side = 0; } else +#endif + { + r_stereo_side = 0; SCR_DrawScreen(); - if (r_viewscale_fpsscaling.integer) - GL_Finish(); - r_refdef.lastdrawscreentime = Sys_DoubleTime() - drawscreenstart; + } +#ifdef CONFIG_VIDEO_CAPTURE SCR_CaptureVideo(); +#endif - if (qglFlush) - qglFlush(); // FIXME: should we really be using qglFlush here? - - // quality adjustment according to render time - cl_updatescreen_rendertime += ((Sys_DoubleTime() - rendertime1) - cl_updatescreen_rendertime) * bound(0, cl_minfps_fade.value, 1); - if (cl_minfps.value > 0 && cl_updatescreen_rendertime > 0 && !cls.timedemo && (!cls.capturevideo.active || !cls.capturevideo.realtime)) - cl_updatescreen_quality = 1 / (cl_updatescreen_rendertime * cl_minfps.value); - else - cl_updatescreen_quality = 1; + qglFlush(); // ensure that the commands are submitted to the GPU before we do other things if (!vid_activewindow) VID_SetMouse(false, false, false);