]> de.git.xonotic.org Git - xonotic/darkplaces.git/blobdiff - cl_screen.c
video modes in menu now also set vid_pixelheight and vid_conwidth/vid_conheight
[xonotic/darkplaces.git] / cl_screen.c
index ba71832dbcbd1757bf5e37640b86d6f3d083fc9d..d7baa8b2a1f3d727d54c940adc106cee994dd59e 100644 (file)
@@ -14,24 +14,30 @@ cvar_t scr_centertime = {0, "scr_centertime","2"};
 cvar_t scr_showram = {CVAR_SAVE, "showram","1"};
 cvar_t scr_showturtle = {CVAR_SAVE, "showturtle","0"};
 cvar_t scr_showpause = {CVAR_SAVE, "showpause","1"};
+cvar_t scr_showbrand = {0, "showbrand","0"};
 cvar_t scr_printspeed = {0, "scr_printspeed","8"};
 cvar_t vid_conwidth = {CVAR_SAVE, "vid_conwidth", "640"};
 cvar_t vid_conheight = {CVAR_SAVE, "vid_conheight", "480"};
-cvar_t scr_screenshot_jpeg = {CVAR_SAVE, "scr_screenshot_jpeg","0"};
+cvar_t vid_pixelheight = {CVAR_SAVE, "vid_pixelheight", "1"};
+cvar_t scr_screenshot_jpeg = {CVAR_SAVE, "scr_screenshot_jpeg","1"};
 cvar_t scr_screenshot_jpeg_quality = {CVAR_SAVE, "scr_screenshot_jpeg_quality","0.9"};
-cvar_t cl_avidemo = {0, "cl_avidemo", "0"};
+cvar_t scr_screenshot_gamma = {CVAR_SAVE, "scr_screenshot_gamma","2.2"};
+// scr_screenshot_name is defined in fs.c
+cvar_t cl_capturevideo = {0, "cl_capturevideo", "0"};
+cvar_t cl_capturevideo_sound = {0, "cl_capturevideo_sound", "0"};
+cvar_t cl_capturevideo_fps = {0, "cl_capturevideo_fps", "30"};
+cvar_t cl_capturevideo_rawrgb = {0, "cl_capturevideo_rawrgb", "0"};
+cvar_t cl_capturevideo_rawyv12 = {0, "cl_capturevideo_rawyv12", "0"};
+cvar_t r_textshadow = {0, "r_textshadow", "0"};
+cvar_t r_letterbox = {0, "r_letterbox", "0"};
 
 int jpeg_supported = false;
 
 qboolean       scr_initialized;                // ready to draw
 
 float          scr_con_current;
-float          scr_conlines;           // lines of console to display
 
-int                    clearconsole;
-int                    clearnotify;
-
-qboolean       scr_drawloading = false;
+extern int     con_vislines;
 
 void DrawCrosshair(int num);
 static void SCR_ScreenShot_f (void);
@@ -40,6 +46,114 @@ static void R_Envmap_f (void);
 // backend
 void R_ClearScreen(void);
 
+// color tag printing
+static vec4_t string_colors[] =
+{
+       // Quake3 colors
+       // LordHavoc: why on earth is cyan before magenta in Quake3?
+       // LordHavoc: note: Doom3 uses white for [0] and [7]
+       {0.0, 0.0, 0.0, 1.0}, // black
+       {1.0, 0.0, 0.0, 1.0}, // red
+       {0.0, 1.0, 0.0, 1.0}, // green
+       {1.0, 1.0, 0.0, 1.0}, // yellow
+       {0.0, 0.0, 1.0, 1.0}, // blue
+       {0.0, 1.0, 1.0, 1.0}, // cyan
+       {1.0, 0.0, 1.0, 1.0}, // magenta
+       {1.0, 1.0, 1.0, 1.0}, // white
+       // [515]'s BX_COLOREDTEXT extension
+       {1.0, 1.0, 1.0, 0.5}, // half transparent
+       {0.5, 0.5, 0.5, 1.0}  // half brightness
+       // Black's color table
+       //{1.0, 1.0, 1.0, 1.0},
+       //{1.0, 0.0, 0.0, 1.0},
+       //{0.0, 1.0, 0.0, 1.0},
+       //{0.0, 0.0, 1.0, 1.0},
+       //{1.0, 1.0, 0.0, 1.0},
+       //{0.0, 1.0, 1.0, 1.0},
+       //{1.0, 0.0, 1.0, 1.0},
+       //{0.1, 0.1, 0.1, 1.0}
+};
+
+#define STRING_COLORS_COUNT    (sizeof(string_colors) / sizeof(vec4_t))
+
+// color is read and changed in the end
+void DrawQ_ColoredString( float x, float y, const char *text, int maxlen, float scalex, float scaley, float basered, float basegreen, float baseblue, float basealpha, int flags, int *outcolor )
+{
+       vec_t *color;
+       int len;
+       int colorindex;
+       const char *start, *current;
+
+       if( !outcolor || *outcolor == -1 ) {
+               colorindex = STRING_COLOR_DEFAULT;
+       } else {
+               colorindex = *outcolor;
+       }
+       color = string_colors[colorindex];
+
+       if( maxlen < 1)
+               len = (int)strlen( text );
+       else
+               len = min( maxlen, (int) strlen( text ) );
+
+       start = current = text;
+       while( len > 0 ) {
+               // check for color control char
+               if( *current == STRING_COLOR_TAG ) {
+                       // get next char
+                       current++;
+                       len--;
+                       if( len == 0 ) {
+                               break;
+                       }
+                       // display the tag char?
+                       if( *current == STRING_COLOR_TAG ) {
+                               // only display one of the two
+                               start = current;
+                               // get the next char
+                               current++;
+                               len--;
+                       } else if( '0' <= *current && *current <= '9' ) {
+                               colorindex = 0;
+                               do {
+                                       colorindex = colorindex * 10 + (*current - '0');
+                                       // only read as long as it makes a valid index
+                                       if( colorindex >= (int)STRING_COLORS_COUNT ) {
+                                               // undo the last operation
+                                               colorindex /= 10;
+                                               break;
+                                       }
+                                       current++;
+                                       len--;
+                               } while( len > 0 && '0' <= *current && *current <= '9' );
+                               // set the color
+                               color = string_colors[colorindex];
+                               // we jump over the color tag
+                               start = current;
+                       }
+               }
+               // go on and read normal text in until the next control char
+               while( len > 0 && *current != STRING_COLOR_TAG ) {
+                       current++;
+                       len--;
+               }
+               // display the text
+               if( start != current ) {
+                       // draw the string
+                       DrawQ_String( x, y, start, current - start, scalex, scaley, basered * color[0], basegreen * color[1], baseblue * color[2], basealpha * color[3], flags );
+                       // update x to be at the new start position
+                       x += (current - start) * scalex;
+                       // set start accordingly
+                       start = current;
+               }
+       }
+
+       // return the last colorindex
+       if( outcolor ) {
+               *outcolor = colorindex;
+       }
+}
+
 /*
 ===============================================================================
 
@@ -48,7 +162,7 @@ CENTER PRINTING
 ===============================================================================
 */
 
-char           scr_centerstring[1024];
+char           scr_centerstring[MAX_INPUTLINE];
 float          scr_centertime_start;   // for slow victory printing
 float          scr_centertime_off;
 int                    scr_center_lines;
@@ -86,6 +200,7 @@ void SCR_DrawCenterString (void)
        int             l;
        int             x, y;
        int             remaining;
+       int             color;
 
 // the finale prints the characters one at a time
        if (cl.intermission)
@@ -96,23 +211,27 @@ void SCR_DrawCenterString (void)
        scr_erase_center = 0;
        start = scr_centerstring;
 
+       if (remaining < 1)
+               return;
+
        if (scr_center_lines <= 4)
-               y = vid.conheight*0.35;
+               y = vid_conheight.integer*0.35;
        else
                y = 48;
 
+       color = -1;
        do
        {
        // scan the width of the line
-               for (l=0 ; l<40 ; l++)
+               for (l=0 ; l<vid_conwidth.integer/8 ; l++)
                        if (start[l] == '\n' || !start[l])
                                break;
-               x = (vid.conwidth - l*8)/2;
+               x = (vid_conwidth.integer - l*8)/2;
                if (l > 0)
                {
                        if (remaining < l)
                                l = remaining;
-                       DrawQ_String(x, y, start, l, 8, 8, 1, 1, 1, 1, 0);
+                       DrawQ_ColoredString(x, y, start, l, 8, 8, 1, 1, 1, 1, 0, &color);
                        remaining -= l;
                        if (remaining <= 0)
                                return;
@@ -173,7 +292,7 @@ void SCR_DrawTurtle (void)
        if (count < 3)
                return;
 
-       DrawQ_Pic (0, 0, "gfx/turtle.lmp", 0, 0, 1, 1, 1, 1, 0);
+       DrawQ_Pic (0, 0, "gfx/turtle", 0, 0, 1, 1, 1, 1, 0);
 }
 
 /*
@@ -190,7 +309,7 @@ void SCR_DrawNet (void)
        if (cls.demoplayback)
                return;
 
-       DrawQ_Pic (64, 0, "gfx/net.lmp", 0, 0, 1, 1, 1, 1, 0);
+       DrawQ_Pic (64, 0, "gfx/net", 0, 0, 1, 1, 1, 1, 0);
 }
 
 /*
@@ -211,26 +330,65 @@ void SCR_DrawPause (void)
        if (!cl.paused)
                return;
 
-       pic = Draw_CachePic ("gfx/pause.lmp");
-       DrawQ_Pic ((vid.conwidth - pic->width)/2, (vid.conheight - pic->height)/2, "gfx/pause.lmp", 0, 0, 1, 1, 1, 1, 0);
+       pic = Draw_CachePic ("gfx/pause", true);
+       DrawQ_Pic ((vid_conwidth.integer - pic->width)/2, (vid_conheight.integer - pic->height)/2, "gfx/pause", 0, 0, 1, 1, 1, 1, 0);
 }
 
-
-
 /*
 ==============
-SCR_DrawLoading
+SCR_DrawBrand
 ==============
 */
-void SCR_DrawLoading (void)
+void SCR_DrawBrand (void)
 {
        cachepic_t      *pic;
+       float           x, y;
 
-       pic = Draw_CachePic ("gfx/loading.lmp");
-       DrawQ_Pic ((vid.conwidth - pic->width)/2, (vid.conheight - pic->height)/2, "gfx/loading.lmp", 0, 0, 1, 1, 1, 1, 0);
-}
+       if (!scr_showbrand.value)
+               return;
 
+       pic = Draw_CachePic ("gfx/brand", true);
 
+       switch ((int)scr_showbrand.value)
+       {
+       case 1: // bottom left
+               x = 0;
+               y = vid_conheight.integer - pic->height;
+               break;
+       case 2: // bottom centre
+               x = (vid_conwidth.integer - pic->width) / 2;
+               y = vid_conheight.integer - pic->height;
+               break;
+       case 3: // bottom right
+               x = vid_conwidth.integer - pic->width;
+               y = vid_conheight.integer - pic->height;
+               break;
+       case 4: // centre right
+               x = vid_conwidth.integer - pic->width;
+               y = (vid_conheight.integer - pic->height) / 2;
+               break;
+       case 5: // top right
+               x = vid_conwidth.integer - pic->width;
+               y = 0;
+               break;
+       case 6: // top centre
+               x = (vid_conwidth.integer - pic->width) / 2;
+               y = 0;
+               break;
+       case 7: // top left
+               x = 0;
+               y = 0;
+               break;
+       case 8: // centre left
+               x = 0;
+               y = (vid_conheight.integer - pic->height) / 2;
+               break;
+       default:
+               return;
+       }
+
+       DrawQ_Pic (x, y, "gfx/brand", 0, 0, 1, 1, 1, 1, 0);
+}
 
 //=============================================================================
 
@@ -242,6 +400,9 @@ SCR_SetUpToDrawConsole
 */
 void SCR_SetUpToDrawConsole (void)
 {
+       // lines of console to display
+       float conlines;
+
        Con_CheckResize ();
 
        if (key_dest == key_game && cls.signon != SIGNONS && scr_conforcewhiledisconnected.integer)
@@ -250,31 +411,29 @@ void SCR_SetUpToDrawConsole (void)
                key_consoleactive &= ~KEY_CONSOLEACTIVE_FORCED;
 
 // decide on the height of the console
-       if (key_consoleactive & KEY_CONSOLEACTIVE_FORCED)
-               scr_conlines = vid.conheight; // full screen
-       else if (key_consoleactive & KEY_CONSOLEACTIVE_USER)
-               scr_conlines = vid.conheight/2; // half screen
+       if (key_consoleactive & KEY_CONSOLEACTIVE_USER)
+               conlines = vid_conheight.integer/2;     // half screen
        else
-               scr_conlines = 0;                               // none visible
+               conlines = 0;                           // none visible
 
        if (scr_conspeed.value)
        {
-               if (scr_conlines < scr_con_current)
+               if (scr_con_current > conlines)
                {
                        scr_con_current -= scr_conspeed.value*host_realframetime;
-                       if (scr_conlines > scr_con_current)
-                               scr_con_current = scr_conlines;
+                       if (scr_con_current < conlines)
+                               scr_con_current = conlines;
 
                }
-               else if (scr_conlines > scr_con_current)
+               else if (scr_con_current < conlines)
                {
                        scr_con_current += scr_conspeed.value*host_realframetime;
-                       if (scr_conlines < scr_con_current)
-                               scr_con_current = scr_conlines;
+                       if (scr_con_current > conlines)
+                               scr_con_current = conlines;
                }
        }
        else
-               scr_con_current = scr_conlines;
+               scr_con_current = conlines;
 }
 
 /*
@@ -284,13 +443,16 @@ SCR_DrawConsole
 */
 void SCR_DrawConsole (void)
 {
-       if (scr_con_current)
+       if (key_consoleactive & KEY_CONSOLEACTIVE_FORCED)
        {
-               Con_DrawConsole (scr_con_current);
-               clearconsole = 0;
+               // full screen
+               Con_DrawConsole (vid_conheight.integer);
        }
+       else if (scr_con_current)
+               Con_DrawConsole (scr_con_current);
        else
        {
+               con_vislines = 0;
                if (key_dest == key_game || key_dest == key_message)
                        Con_DrawNotify ();      // only draw notify in game
        }
@@ -304,15 +466,9 @@ SCR_BeginLoadingPlaque
 */
 void SCR_BeginLoadingPlaque (void)
 {
-       if (scr_drawloading)
-               return;
-
-       S_StopAllSounds (true);
-
-       scr_drawloading = true;
-       CL_UpdateScreen ();
-       scr_drawloading = true;
-       CL_UpdateScreen ();
+       Host_StartVideo();
+       S_StopAllSounds();
+       SCR_UpdateLoadingScreen();
 }
 
 //=============================================================================
@@ -327,39 +483,37 @@ void R_TimeReport(char *desc)
        int length;
        int t;
 
-       if (!r_timereport_active)
+       if (!r_timereport_active || r_showtrispass)
                return;
 
+       qglFinish();
        r_timereport_temp = r_timereport_current;
        r_timereport_current = Sys_DoubleTime();
        t = (int) ((r_timereport_current - r_timereport_temp) * 1000000.0);
 
-       sprintf(tempbuf, "%8i %s", t, desc);
-       length = strlen(tempbuf);
+       dpsnprintf(tempbuf, sizeof(tempbuf), "%8i %s", t, desc);
+       length = (int)strlen(tempbuf);
        while (length < 20)
                tempbuf[length++] = ' ';
        tempbuf[length] = 0;
-       if (speedstringcount + length > (vid.conwidth / 8))
+       if (speedstringcount + length > (vid_conwidth.integer / 8))
        {
-               strcat(r_speeds_string, "\n");
+               strlcat(r_speeds_string, "\n", sizeof(r_speeds_string));
                speedstringcount = 0;
        }
        // skip the space at the beginning if it's the first on the line
        if (speedstringcount == 0)
        {
-               strcat(r_speeds_string, tempbuf + 1);
+               strlcat(r_speeds_string, tempbuf + 1, sizeof(r_speeds_string));
                speedstringcount = length - 1;
        }
        else
        {
-               strcat(r_speeds_string, tempbuf);
+               strlcat(r_speeds_string, tempbuf, sizeof(r_speeds_string));
                speedstringcount += length;
        }
 }
 
-extern int c_rt_lights, c_rt_clears, c_rt_scissored;
-extern int c_rt_shadowmeshes, c_rt_shadowtris, c_rt_lightmeshes, c_rt_lighttris;
-extern int c_rtcached_shadowmeshes, c_rtcached_shadowtris;
 void R_TimeReport_Start(void)
 {
        r_timereport_active = r_speeds.integer && cls.signon == SIGNONS && cls.state == ca_connected;
@@ -367,38 +521,18 @@ void R_TimeReport_Start(void)
        if (r_timereport_active)
        {
                speedstringcount = 0;
-               sprintf(r_speeds_string,
-                       "org:'%+8.2f %+8.2f %+8.2f' dir:'%+2.3f %+2.3f %+2.3f'\n"
-                       "world:%6i faces%6i nodes%6i leafs%6i dlitwalls\n"
-                       "%5i models%5i bmodels%5i sprites%6i particles%4i dlights\n"
-                       "%6i modeltris%6i meshs%6i meshtris\n",
-                       r_vieworigin[0], r_vieworigin[1], r_vieworigin[2], r_viewforward[0], r_viewforward[1], r_viewforward[2],
-                       c_faces, c_nodes, c_leafs, c_light_polys,
-                       c_models, c_bmodels, c_sprites, c_particles, c_dlights,
-                       c_alias_polys, c_meshs, c_meshelements / 3);
-
-               sprintf(r_speeds_string + strlen(r_speeds_string),
-                       "realtime lighting:%4i lights%4i clears%4i scissored\n"
-                       "dynamic: %6i shadowmeshes%6i shadowtris%6i lightmeshes%6i lighttris\n"
-                       "precomputed: %6i shadowmeshes%6i shadowtris\n",
-                       c_rt_lights, c_rt_clears, c_rt_scissored,
-                       c_rt_shadowmeshes, c_rt_shadowtris, c_rt_lightmeshes, c_rt_lighttris,
-                       c_rtcached_shadowmeshes, c_rtcached_shadowtris);
-
-               c_alias_polys = 0;
-               c_light_polys = 0;
-               c_faces = 0;
-               c_nodes = 0;
-               c_leafs = 0;
-               c_models = 0;
-               c_bmodels = 0;
-               c_sprites = 0;
-               c_particles = 0;
-               c_meshs = 0;
-               c_meshelements = 0;
+               sprintf(r_speeds_string + strlen(r_speeds_string), "org:'%+8.2f %+8.2f %+8.2f' dir:'%+2.3f %+2.3f %+2.3f'\n", r_vieworigin[0], r_vieworigin[1], r_vieworigin[2], r_viewforward[0], r_viewforward[1], r_viewforward[2]);
+               sprintf(r_speeds_string + strlen(r_speeds_string), "%5i entities%6i surfaces%6i triangles%5i leafs%5i portals%6i particles\n", renderstats.entities, renderstats.entities_surfaces, renderstats.entities_triangles, renderstats.world_leafs, renderstats.world_portals, renderstats.particles);
+               sprintf(r_speeds_string + strlen(r_speeds_string), "%4i lights%4i clears%4i scissored%7i light%7i shadow%7i dynamic\n", renderstats.lights, renderstats.lights_clears, renderstats.lights_scissored, renderstats.lights_lighttriangles, renderstats.lights_shadowtriangles, renderstats.lights_dynamicshadowtriangles);
+               if (renderstats.bloom)
+                       sprintf(r_speeds_string + strlen(r_speeds_string), "rendered%6i meshes%8i triangles bloompixels%8i copied%8i drawn\n", renderstats.meshes, renderstats.meshes_elements / 3, renderstats.bloom_copypixels, renderstats.bloom_drawpixels);
+               else
+                       sprintf(r_speeds_string + strlen(r_speeds_string), "rendered%6i meshes%8i triangles\n", renderstats.meshes, renderstats.meshes_elements / 3);
 
                r_timereport_start = Sys_DoubleTime();
        }
+
+       memset(&renderstats, 0, sizeof(renderstats));
 }
 
 void R_TimeReport_End(void)
@@ -413,9 +547,9 @@ void R_TimeReport_End(void)
                for (i = 0;r_speeds_string[i];i++)
                        if (r_speeds_string[i] == '\n')
                                lines++;
-               y = vid.conheight - sb_lines - lines * 8;
+               y = vid_conheight.integer - sb_lines - lines * 8;
                i = j = 0;
-               DrawQ_Fill(0, y, vid.conwidth, lines * 8, 0, 0, 0, 0.5, 0);
+               DrawQ_Fill(0, y, vid_conwidth.integer, lines * 8, 0, 0, 0, 0.5, 0);
                while (r_speeds_string[i])
                {
                        j = i;
@@ -466,13 +600,22 @@ void CL_Screen_Init(void)
        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 (&vid_conwidth);
        Cvar_RegisterVariable (&vid_conheight);
+       Cvar_RegisterVariable (&vid_pixelheight);
        Cvar_RegisterVariable (&scr_screenshot_jpeg);
        Cvar_RegisterVariable (&scr_screenshot_jpeg_quality);
-       Cvar_RegisterVariable (&cl_avidemo);
+       Cvar_RegisterVariable (&scr_screenshot_gamma);
+       Cvar_RegisterVariable (&cl_capturevideo);
+       Cvar_RegisterVariable (&cl_capturevideo_sound);
+       Cvar_RegisterVariable (&cl_capturevideo_fps);
+       Cvar_RegisterVariable (&cl_capturevideo_rawrgb);
+       Cvar_RegisterVariable (&cl_capturevideo_rawyv12);
+       Cvar_RegisterVariable (&r_textshadow);
+       Cvar_RegisterVariable (&r_letterbox);
 
        Cmd_AddCommand ("sizeup",SCR_SizeUp_f);
        Cmd_AddCommand ("sizedown",SCR_SizeDown_f);
@@ -488,12 +631,12 @@ void DrawQ_Clear(void)
 }
 
 static int picelements[6] = {0, 1, 2, 0, 2, 3};
-void DrawQ_Pic(float x, float y, char *picname, float width, float height, float red, float green, float blue, float alpha, int flags)
+void DrawQ_Pic(float x, float y, const char *picname, float width, float height, float red, float green, float blue, float alpha, int flags)
 {
        DrawQ_SuperPic(x,y,picname,width,height,0,0,red,green,blue,alpha,1,0,red,green,blue,alpha,0,1,red,green,blue,alpha,1,1,red,green,blue,alpha,flags);
 }
 
-void DrawQ_String(float x, float y, const char *string, int maxlen, float scalex, float scaley, float red, float green, float blue, float alpha, int flags)
+void DrawQ_String_Real(float x, float y, const char *string, int maxlen, float scalex, float scaley, float red, float green, float blue, float alpha, int flags)
 {
        int size, len;
        drawqueue_t *dq;
@@ -501,14 +644,14 @@ void DrawQ_String(float x, float y, const char *string, int maxlen, float scalex
        if (alpha < (1.0f / 255.0f))
                return;
        if (maxlen < 1)
-               len = strlen(string);
+               len = (int)strlen(string);
        else
                for (len = 0;len < maxlen && string[len];len++);
        for (;len > 0 && string[0] == ' ';string++, x += scalex, len--);
        for (;len > 0 && string[len - 1] == ' ';len--);
        if (len < 1)
                return;
-       if (x >= vid.conwidth || y >= vid.conheight || x < (-scalex * maxlen) || y < (-scaley))
+       if (x >= vid_conwidth.integer || y >= vid_conheight.integer || x < (-scalex * len) || y < (-scaley))
                return;
        size = sizeof(*dq) + ((len + 1 + 3) & ~3);
        if (r_refdef.drawqueuesize + size > r_refdef.maxdrawqueuesize)
@@ -517,7 +660,7 @@ void DrawQ_String(float x, float y, const char *string, int maxlen, float scalex
        green = bound(0, green, 1);
        blue = bound(0, blue, 1);
        alpha = bound(0, alpha, 1);
-       dq = (void *)(r_refdef.drawqueue + r_refdef.drawqueuesize);
+       dq = (drawqueue_t *)(r_refdef.drawqueue + r_refdef.drawqueuesize);
        dq->size = size;
        dq->command = DRAWQUEUE_STRING;
        dq->flags = flags;
@@ -532,12 +675,22 @@ void DrawQ_String(float x, float y, const char *string, int maxlen, float scalex
        r_refdef.drawqueuesize += dq->size;
 }
 
+void DrawQ_String(float x, float y, const char *string, int maxlen, float scalex, float scaley, float red, float green, float blue, float alpha, int flags)
+{
+       if (r_textshadow.integer)
+               DrawQ_String_Real(x+scalex*0.25,y+scaley*0.25,string,maxlen,scalex,scaley,0,0,0,alpha*0.8,flags);
+
+       DrawQ_String_Real(x,y,string,maxlen,scalex,scaley,red,green,blue,alpha,flags);
+}
+
+
+
 void DrawQ_Fill (float x, float y, float w, float h, float red, float green, float blue, float alpha, int flags)
 {
        DrawQ_SuperPic(x,y,NULL,w,h,0,0,red,green,blue,alpha,1,0,red,green,blue,alpha,0,1,red,green,blue,alpha,1,1,red,green,blue,alpha,flags);
 }
 
-void DrawQ_SuperPic(float x, float y, char *picname, float width, float height, float s1, float t1, float r1, float g1, float b1, float a1, float s2, float t2, float r2, float g2, float b2, float a2, float s3, float t3, float r3, float g3, float b3, float a3, float s4, float t4, float r4, float g4, float b4, float a4, int flags)
+void DrawQ_SuperPic(float x, float y, const char *picname, float width, float height, float s1, float t1, float r1, float g1, float b1, float a1, float s2, float t2, float r2, float g2, float b2, float a2, float s3, float t3, float r3, float g3, float b3, float a3, float s4, float t4, float r4, float g4, float b4, float a4, int flags)
 {
        float floats[36];
        cachepic_t *pic;
@@ -545,7 +698,7 @@ void DrawQ_SuperPic(float x, float y, char *picname, float width, float height,
        memset(&mesh, 0, sizeof(mesh));
        if (picname && picname[0])
        {
-               pic = Draw_CachePic(picname);
+               pic = Draw_CachePic(picname, false);
                if (width == 0)
                        width = pic->width;
                if (height == 0)
@@ -584,7 +737,7 @@ void DrawQ_Mesh (drawqueuemesh_t *mesh, int flags)
        size += sizeof(float[4]) * mesh->num_vertices;
        if (r_refdef.drawqueuesize + size > r_refdef.maxdrawqueuesize)
                return;
-       dq = (void *)(r_refdef.drawqueue + r_refdef.drawqueuesize);
+       dq = (drawqueue_t *)(r_refdef.drawqueue + r_refdef.drawqueuesize);
        dq->size = size;
        dq->command = DRAWQUEUE_MESH;
        dq->flags = flags;
@@ -594,14 +747,14 @@ void DrawQ_Mesh (drawqueuemesh_t *mesh, int flags)
        dq->scalex = 0;
        dq->scaley = 0;
        p = (void *)(dq + 1);
-       m = p;(qbyte *)p += sizeof(drawqueuemesh_t);
+       m = (drawqueuemesh_t *)p;p = (unsigned char*)p + sizeof(drawqueuemesh_t);
        m->num_triangles = mesh->num_triangles;
        m->num_vertices = mesh->num_vertices;
        m->texture = mesh->texture;
-       m->data_element3i  = p;memcpy(m->data_element3i , mesh->data_element3i , m->num_triangles * sizeof(int[3]));(qbyte *)p += m->num_triangles * sizeof(int[3]);
-       m->data_vertex3f   = p;memcpy(m->data_vertex3f  , mesh->data_vertex3f  , m->num_vertices * sizeof(float[3]));(qbyte *)p += m->num_vertices * sizeof(float[3]);
-       m->data_texcoord2f = p;memcpy(m->data_texcoord2f, mesh->data_texcoord2f, m->num_vertices * sizeof(float[2]));(qbyte *)p += m->num_vertices * sizeof(float[2]);
-       m->data_color4f    = p;memcpy(m->data_color4f   , mesh->data_color4f   , m->num_vertices * sizeof(float[4]));(qbyte *)p += m->num_vertices * sizeof(float[4]);
+       m->data_element3i  = (int *)p;memcpy(m->data_element3i , mesh->data_element3i , m->num_triangles * sizeof(int[3]));p = (unsigned char*)p + m->num_triangles * sizeof(int[3]);
+       m->data_vertex3f   = (float *)p;memcpy(m->data_vertex3f  , mesh->data_vertex3f  , m->num_vertices * sizeof(float[3]));p = (unsigned char*)p + m->num_vertices * sizeof(float[3]);
+       m->data_texcoord2f = (float *)p;memcpy(m->data_texcoord2f, mesh->data_texcoord2f, m->num_vertices * sizeof(float[2]));p = (unsigned char*)p + m->num_vertices * sizeof(float[2]);
+       m->data_color4f    = (float *)p;memcpy(m->data_color4f   , mesh->data_color4f   , m->num_vertices * sizeof(float[4]));p = (unsigned char*)p + m->num_vertices * sizeof(float[4]);
        r_refdef.drawqueuesize += dq->size;
 }
 
@@ -613,7 +766,7 @@ void DrawQ_SetClipArea(float x, float y, float width, float height)
                Con_DPrint("DrawQueue full !\n");
                return;
        }
-       dq = (void*) (r_refdef.drawqueue + r_refdef.drawqueuesize);
+       dq = (drawqueue_t *) (r_refdef.drawqueue + r_refdef.drawqueuesize);
        dq->size = sizeof(*dq);
        dq->command = DRAWQUEUE_SETCLIP;
        dq->x = x;
@@ -634,7 +787,7 @@ void DrawQ_ResetClipArea(void)
                Con_DPrint("DrawQueue full !\n");
                return;
        }
-       dq = (void*) (r_refdef.drawqueue + r_refdef.drawqueuesize);
+       dq = (drawqueue_t *) (r_refdef.drawqueue + r_refdef.drawqueuesize);
        dq->size = sizeof(*dq);
        dq->command = DRAWQUEUE_RESETCLIP;
        dq->x = 0;
@@ -654,15 +807,23 @@ SCR_ScreenShot_f
 */
 void SCR_ScreenShot_f (void)
 {
-       static int shotnumber = 0;
-       const char *base;
-       char filename[64];
+       static int shotnumber;
+       static char oldname[MAX_QPATH];
+       char base[MAX_QPATH];
+       char filename[MAX_QPATH];
+       unsigned char *buffer1;
+       unsigned char *buffer2;
+       unsigned char *buffer3;
        qboolean jpeg = (scr_screenshot_jpeg.integer != 0);
 
-       base = "screenshots/dp";
-       if (gamemode == GAME_FNIGGIUM)
-               base = "screenshots/fniggium";
-       
+       sprintf (base, "screenshots/%s", scr_screenshot_name.string);
+
+       if (strcmp (oldname, scr_screenshot_name.string))
+       {
+               sprintf(oldname, "%s", scr_screenshot_name.string);
+               shotnumber = 0;
+       }
+
        // find a file name to save it to
        for (;shotnumber < 1000000;shotnumber++)
                if (!FS_SysFileExists(va("%s/%s%06d.tga", fs_gamedir, base, shotnumber)) && !FS_SysFileExists(va("%s/%s%06d.jpg", fs_gamedir, base, shotnumber)))
@@ -673,38 +834,338 @@ void SCR_ScreenShot_f (void)
                return;
        }
 
-       if (jpeg)
-               sprintf(filename, "%s%06d.jpg", base, shotnumber);
-       else
-               sprintf(filename, "%s%06d.tga", base, shotnumber);
+       sprintf(filename, "%s%06d.%s", base, shotnumber, jpeg ? "jpg" : "tga");
+
+       buffer1 = (unsigned char *)Mem_Alloc(tempmempool, vid.width * vid.height * 3);
+       buffer2 = (unsigned char *)Mem_Alloc(tempmempool, vid.width * vid.height * 3);
+       buffer3 = (unsigned char *)Mem_Alloc(tempmempool, vid.width * vid.height * 3 + 18);
 
-       if (SCR_ScreenShot(filename, vid.realx, vid.realy, vid.realwidth, vid.realheight, jpeg))
+       if (SCR_ScreenShot (filename, buffer1, buffer2, buffer3, 0, 0, vid.width, vid.height, false, false, false, jpeg, true))
                Con_Printf("Wrote %s\n", filename);
        else
                Con_Printf("unable to write %s\n", filename);
+
+       Mem_Free (buffer1);
+       Mem_Free (buffer2);
+       Mem_Free (buffer3);
+
        shotnumber++;
 }
 
-static int cl_avidemo_frame = 0;
-
-void SCR_CaptureAVIDemo(void)
+typedef enum capturevideoformat_e
 {
-       char filename[32];
-       qboolean jpeg = (scr_screenshot_jpeg.integer != 0);
+       CAPTUREVIDEOFORMAT_TARGA,
+       CAPTUREVIDEOFORMAT_JPEG,
+       CAPTUREVIDEOFORMAT_RAWRGB,
+       CAPTUREVIDEOFORMAT_RAWYV12
+}
+capturevideoformat_t;
+
+qboolean cl_capturevideo_active = false;
+capturevideoformat_t cl_capturevideo_format;
+static double cl_capturevideo_starttime = 0;
+double cl_capturevideo_framerate = 0;
+static int cl_capturevideo_soundrate = 0;
+static int cl_capturevideo_frame = 0;
+static unsigned char *cl_capturevideo_buffer = NULL;
+static qfile_t *cl_capturevideo_videofile = NULL;
+qfile_t *cl_capturevideo_soundfile = NULL;
+static short cl_capturevideo_rgbtoyuvscaletable[3][3][256];
+static unsigned char cl_capturevideo_yuvnormalizetable[3][256];
+//static unsigned char cl_capturevideo_rgbgammatable[3][256];
+
+void SCR_CaptureVideo_BeginVideo(void)
+{
+       double gamma, g;
+       unsigned int i;
+       unsigned char out[44];
+       if (cl_capturevideo_active)
+               return;
+       // soundrate is figured out on the first SoundFrame
+       cl_capturevideo_active = true;
+       cl_capturevideo_starttime = Sys_DoubleTime();
+       cl_capturevideo_framerate = bound(1, cl_capturevideo_fps.value, 1000);
+       cl_capturevideo_soundrate = 0;
+       cl_capturevideo_frame = 0;
+       cl_capturevideo_buffer = (unsigned char *)Mem_Alloc(tempmempool, vid.width * vid.height * (3+3+3) + 18);
+       gamma = 1.0/scr_screenshot_gamma.value;
+
+       /*
+       for (i = 0;i < 256;i++)
+       {
+               unsigned char j = (unsigned char)bound(0, 255*pow(i/255.0, gamma), 255);
+               cl_capturevideo_rgbgammatable[0][i] = j;
+               cl_capturevideo_rgbgammatable[1][i] = j;
+               cl_capturevideo_rgbgammatable[2][i] = j;
+       }
+       */
+/*
+R = Y + 1.4075 * (Cr - 128);
+G = Y + -0.3455 * (Cb - 128) + -0.7169 * (Cr - 128);
+B = Y + 1.7790 * (Cb - 128);
+Y = R *  .299 + G *  .587 + B *  .114;
+Cb = R * -.169 + G * -.332 + B *  .500 + 128.;
+Cr = R *  .500 + G * -.419 + B * -.0813 + 128.;
+*/
+       for (i = 0;i < 256;i++)
+       {
+               g = 255*pow(i/255.0, gamma);
+               // Y weights from RGB
+               cl_capturevideo_rgbtoyuvscaletable[0][0][i] = (short)(g *  0.299);
+               cl_capturevideo_rgbtoyuvscaletable[0][1][i] = (short)(g *  0.587);
+               cl_capturevideo_rgbtoyuvscaletable[0][2][i] = (short)(g *  0.114);
+               // Cb weights from RGB
+               cl_capturevideo_rgbtoyuvscaletable[1][0][i] = (short)(g * -0.169);
+               cl_capturevideo_rgbtoyuvscaletable[1][1][i] = (short)(g * -0.332);
+               cl_capturevideo_rgbtoyuvscaletable[1][2][i] = (short)(g *  0.500);
+               // Cr weights from RGB
+               cl_capturevideo_rgbtoyuvscaletable[2][0][i] = (short)(g *  0.500);
+               cl_capturevideo_rgbtoyuvscaletable[2][1][i] = (short)(g * -0.419);
+               cl_capturevideo_rgbtoyuvscaletable[2][2][i] = (short)(g * -0.0813);
+               // range reduction of YCbCr to valid signal range
+               cl_capturevideo_yuvnormalizetable[0][i] = 16 + i * (236-16) / 256;
+               cl_capturevideo_yuvnormalizetable[1][i] = 16 + i * (240-16) / 256;
+               cl_capturevideo_yuvnormalizetable[2][i] = 16 + i * (240-16) / 256;
+       }
 
-       if (jpeg)
-               sprintf(filename, "video/dp%06d.jpg", cl_avidemo_frame);
+       if (cl_capturevideo_rawrgb.integer)
+       {
+               cl_capturevideo_format = CAPTUREVIDEOFORMAT_RAWRGB;
+               cl_capturevideo_videofile = FS_Open ("video/dpvideo.rgb", "wb", false, true);
+       }
+       else if (cl_capturevideo_rawyv12.integer)
+       {
+               cl_capturevideo_format = CAPTUREVIDEOFORMAT_RAWYV12;
+               cl_capturevideo_videofile = FS_Open ("video/dpvideo.yv12", "wb", false, true);
+       }
+       else if (scr_screenshot_jpeg.integer)
+       {
+               cl_capturevideo_format = CAPTUREVIDEOFORMAT_JPEG;
+               cl_capturevideo_videofile = NULL;
+       }
        else
-               sprintf(filename, "video/dp%06d.tga", cl_avidemo_frame);
+       {
+               cl_capturevideo_format = CAPTUREVIDEOFORMAT_TARGA;
+               cl_capturevideo_videofile = NULL;
+       }
 
-       if (SCR_ScreenShot(filename, vid.realx, vid.realy, vid.realwidth, vid.realheight, jpeg))
-               cl_avidemo_frame++;
+       if (cl_capturevideo_sound.integer)
+       {
+               cl_capturevideo_soundfile = FS_Open ("video/dpvideo.wav", "wb", false, true);
+               // wave header will be filled out when video ends
+               memset(out, 0, 44);
+               FS_Write (cl_capturevideo_soundfile, out, 44);
+       }
        else
+               cl_capturevideo_soundfile = NULL;
+}
+
+void SCR_CaptureVideo_EndVideo(void)
+{
+       int i, n;
+       unsigned char out[44];
+       if (!cl_capturevideo_active)
+               return;
+       cl_capturevideo_active = false;
+
+       if (cl_capturevideo_videofile)
+       {
+               FS_Close(cl_capturevideo_videofile);
+               cl_capturevideo_videofile = NULL;
+       }
+
+       // finish the wave file
+       if (cl_capturevideo_soundfile)
+       {
+               i = (int)FS_Tell (cl_capturevideo_soundfile);
+               //"RIFF", (int) unknown (chunk size), "WAVE",
+               //"fmt ", (int) 16 (chunk size), (short) format 1 (uncompressed PCM), (short) 2 channels, (int) unknown rate, (int) unknown bytes per second, (short) 4 bytes per sample (channels * bytes per channel), (short) 16 bits per channel
+               //"data", (int) unknown (chunk size)
+               memcpy (out, "RIFF****WAVEfmt \x10\x00\x00\x00\x01\x00\x02\x00********\x04\x00\x10\0data****", 44);
+               // the length of the whole RIFF chunk
+               n = i - 8;
+               out[4] = (n) & 0xFF;
+               out[5] = (n >> 8) & 0xFF;
+               out[6] = (n >> 16) & 0xFF;
+               out[7] = (n >> 24) & 0xFF;
+               // rate
+               n = cl_capturevideo_soundrate;
+               out[24] = (n) & 0xFF;
+               out[25] = (n >> 8) & 0xFF;
+               out[26] = (n >> 16) & 0xFF;
+               out[27] = (n >> 24) & 0xFF;
+               // bytes per second (rate * channels * bytes per channel)
+               n = cl_capturevideo_soundrate * 2 * 2;
+               out[28] = (n) & 0xFF;
+               out[29] = (n >> 8) & 0xFF;
+               out[30] = (n >> 16) & 0xFF;
+               out[31] = (n >> 24) & 0xFF;
+               // the length of the data chunk
+               n = i - 44;
+               out[40] = (n) & 0xFF;
+               out[41] = (n >> 8) & 0xFF;
+               out[42] = (n >> 16) & 0xFF;
+               out[43] = (n >> 24) & 0xFF;
+               FS_Seek (cl_capturevideo_soundfile, 0, SEEK_SET);
+               FS_Write (cl_capturevideo_soundfile, out, 44);
+               FS_Close (cl_capturevideo_soundfile);
+               cl_capturevideo_soundfile = NULL;
+       }
+
+       if (cl_capturevideo_buffer)
+       {
+               Mem_Free (cl_capturevideo_buffer);
+               cl_capturevideo_buffer = NULL;
+       }
+
+       cl_capturevideo_starttime = 0;
+       cl_capturevideo_framerate = 0;
+       cl_capturevideo_frame = 0;
+}
+
+qboolean SCR_CaptureVideo_VideoFrame(int newframenum)
+{
+       int x = 0, y = 0, width = vid.width, height = vid.height;
+       unsigned char *b, *out;
+       char filename[32];
+       int outoffset = (width/2)*(height/2);
+       //return SCR_ScreenShot(filename, cl_capturevideo_buffer, cl_capturevideo_buffer + vid.width * vid.height * 3, cl_capturevideo_buffer + vid.width * vid.height * 6, 0, 0, vid.width, vid.height, false, false, false, jpeg, true);
+       // speed is critical here, so do saving as directly as possible
+       switch (cl_capturevideo_format)
+       {
+       case CAPTUREVIDEOFORMAT_RAWYV12:
+               // FIXME: width/height must be multiple of 2, enforce this?
+               qglReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, cl_capturevideo_buffer);
+               CHECKGLERROR
+               // process one line at a time, and CbCr every other line at 2 pixel intervals
+               for (y = 0;y < height;y++)
+               {
+                       // 1x1 Y
+                       for (b = cl_capturevideo_buffer + (height-1-y)*width*3, out = cl_capturevideo_buffer + width*height*3 + y*width, x = 0;x < width;x++, b += 3, out++)
+                               *out = cl_capturevideo_yuvnormalizetable[0][cl_capturevideo_rgbtoyuvscaletable[0][0][b[0]] + cl_capturevideo_rgbtoyuvscaletable[0][1][b[1]] + cl_capturevideo_rgbtoyuvscaletable[0][2][b[2]]];
+                       if ((y & 1) == 0)
+                       {
+                               // 2x2 Cb and Cr planes
+#if 1
+                               // low quality, no averaging
+                               for (b = cl_capturevideo_buffer + (height-2-y)*width*3, out = cl_capturevideo_buffer + width*height*3 + width*height + (y/2)*(width/2), x = 0;x < width/2;x++, b += 6, out++)
+                               {
+                                       // Cr
+                                       out[0        ] = cl_capturevideo_yuvnormalizetable[2][cl_capturevideo_rgbtoyuvscaletable[2][0][b[0]] + cl_capturevideo_rgbtoyuvscaletable[2][1][b[1]] + cl_capturevideo_rgbtoyuvscaletable[2][2][b[2]] + 128];
+                                       // Cb
+                                       out[outoffset] = cl_capturevideo_yuvnormalizetable[1][cl_capturevideo_rgbtoyuvscaletable[1][0][b[0]] + cl_capturevideo_rgbtoyuvscaletable[1][1][b[1]] + cl_capturevideo_rgbtoyuvscaletable[1][2][b[2]] + 128];
+                               }
+#else
+                               // high quality, averaging
+                               int inpitch = width*3;
+                               for (b = cl_capturevideo_buffer + (height-2-y)*width*3, out = cl_capturevideo_buffer + width*height*3 + width*height + (y/2)*(width/2), x = 0;x < width/2;x++, b += 6, out++)
+                               {
+                                       int blockr, blockg, blockb;
+                                       blockr = (b[0] + b[3] + b[inpitch+0] + b[inpitch+3]) >> 2;
+                                       blockg = (b[1] + b[4] + b[inpitch+1] + b[inpitch+4]) >> 2;
+                                       blockb = (b[2] + b[5] + b[inpitch+2] + b[inpitch+5]) >> 2;
+                                       // Cr
+                                       out[0        ] = cl_capturevideo_yuvnormalizetable[2][cl_capturevideo_rgbtoyuvscaletable[2][0][blockr] + cl_capturevideo_rgbtoyuvscaletable[2][1][blockg] + cl_capturevideo_rgbtoyuvscaletable[2][2][blockb] + 128];
+                                       // Cb
+                                       out[outoffset] = cl_capturevideo_yuvnormalizetable[1][cl_capturevideo_rgbtoyuvscaletable[1][0][blockr] + cl_capturevideo_rgbtoyuvscaletable[1][1][blockg] + cl_capturevideo_rgbtoyuvscaletable[1][2][blockb] + 128];
+                               }
+#endif
+                       }
+               }
+               for (;cl_capturevideo_frame < newframenum;cl_capturevideo_frame++)
+                       if (!FS_Write (cl_capturevideo_videofile, cl_capturevideo_buffer + width*height*3, width*height+(width/2)*(height/2)*2))
+                               return false;
+               return true;
+       case CAPTUREVIDEOFORMAT_RAWRGB:
+               qglReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, cl_capturevideo_buffer);
+               CHECKGLERROR
+               for (;cl_capturevideo_frame < newframenum;cl_capturevideo_frame++)
+                       if (!FS_Write (cl_capturevideo_videofile, cl_capturevideo_buffer, width*height*3))
+                               return false;
+               return true;
+       case CAPTUREVIDEOFORMAT_JPEG:
+               qglReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, cl_capturevideo_buffer);
+               CHECKGLERROR
+               for (;cl_capturevideo_frame < newframenum;cl_capturevideo_frame++)
+               {
+                       sprintf(filename, "video/dp%06d.jpg", cl_capturevideo_frame);
+                       if (!JPEG_SaveImage_preflipped (filename, width, height, cl_capturevideo_buffer))
+                               return false;
+               }
+               return true;
+       case CAPTUREVIDEOFORMAT_TARGA:
+               //return Image_WriteTGARGB_preflipped (filename, width, height, cl_capturevideo_buffer, cl_capturevideo_buffer + vid.width * vid.height * 3, );
+               memset (cl_capturevideo_buffer, 0, 18);
+               cl_capturevideo_buffer[2] = 2;          // uncompressed type
+               cl_capturevideo_buffer[12] = (width >> 0) & 0xFF;
+               cl_capturevideo_buffer[13] = (width >> 8) & 0xFF;
+               cl_capturevideo_buffer[14] = (height >> 0) & 0xFF;
+               cl_capturevideo_buffer[15] = (height >> 8) & 0xFF;
+               cl_capturevideo_buffer[16] = 24;        // pixel size
+               qglReadPixels (x, y, width, height, GL_BGR, GL_UNSIGNED_BYTE, cl_capturevideo_buffer + 18);
+               CHECKGLERROR
+               for (;cl_capturevideo_frame < newframenum;cl_capturevideo_frame++)
+               {
+                       sprintf(filename, "video/dp%06d.tga", cl_capturevideo_frame);
+                       if (!FS_WriteFile (filename, cl_capturevideo_buffer, width*height*3 + 18))
+                               return false;
+               }
+               return true;
+       default:
+               return false;
+       }
+}
+
+void SCR_CaptureVideo_SoundFrame(unsigned char *bufstereo16le, size_t length, int rate)
+{
+       if (!cl_capturevideo_soundfile)
+               return;
+       cl_capturevideo_soundrate = rate;
+       if (FS_Write (cl_capturevideo_soundfile, bufstereo16le, 4 * length) < (fs_offset_t)(4 * length))
+       {
+               Cvar_SetValueQuick(&cl_capturevideo, 0);
+               Con_Printf("video sound saving failed on frame %i, out of disk space? stopping video capture.\n", cl_capturevideo_frame);
+               SCR_CaptureVideo_EndVideo();
+       }
+}
+
+void SCR_CaptureVideo(void)
+{
+       int newframenum;
+       if (cl_capturevideo.integer && r_render.integer)
        {
-               Cvar_SetValueQuick(&cl_avidemo, 0);
-               Con_Printf("avi saving failed on frame %i, out of disk space?  stopping avi demo catpure.\n", cl_avidemo_frame);
-               cl_avidemo_frame = 0;
+               if (!cl_capturevideo_active)
+                       SCR_CaptureVideo_BeginVideo();
+               if (cl_capturevideo_framerate != cl_capturevideo_fps.value)
+               {
+                       Con_Printf("You can not change the video framerate while recording a video.\n");
+                       Cvar_SetValueQuick(&cl_capturevideo_fps, cl_capturevideo_framerate);
+               }
+               if (cl_capturevideo_soundfile)
+               {
+                       // preserve sound sync by duplicating frames when running slow
+                       newframenum = (Sys_DoubleTime() - cl_capturevideo_starttime) * cl_capturevideo_framerate;
+               }
+               else
+                       newframenum = cl_capturevideo_frame + 1;
+               // if falling behind more than one second, stop
+               if (newframenum - cl_capturevideo_frame > (int)ceil(cl_capturevideo_framerate))
+               {
+                       Cvar_SetValueQuick(&cl_capturevideo, 0);
+                       Con_Printf("video saving failed on frame %i, your machine is too slow for this capture speed.\n", cl_capturevideo_frame);
+                       SCR_CaptureVideo_EndVideo();
+                       return;
+               }
+               // write frames
+               if (!SCR_CaptureVideo_VideoFrame(newframenum))
+               {
+                       Cvar_SetValueQuick(&cl_capturevideo, 0);
+                       Con_Printf("video saving failed on frame %i, out of disk space? stopping video capture.\n", cl_capturevideo_frame);
+                       SCR_CaptureVideo_EndVideo();
+               }
        }
+       else if (cl_capturevideo_active)
+               SCR_CaptureVideo_EndVideo();
 }
 
 /*
@@ -714,25 +1175,36 @@ R_Envmap_f
 Grab six views for environment mapping tests
 ===============
 */
-struct
+struct envmapinfo_s
 {
        float angles[3];
        char *name;
+       qboolean flipx, flipy, flipdiagonaly;
 }
-envmapinfo[6] =
+envmapinfo[12] =
 {
-       {{  0,   0, 0}, "ft"},
-       {{  0,  90, 0}, "rt"},
-       {{  0, 180, 0}, "bk"},
-       {{  0, 270, 0}, "lf"},
-       {{-90,  90, 0}, "up"},
-       {{ 90,  90, 0}, "dn"}
+       {{  0,   0, 0}, "rt", false, false, false},
+       {{  0, 270, 0}, "ft", false, false, false},
+       {{  0, 180, 0}, "lf", false, false, false},
+       {{  0,  90, 0}, "bk", false, false, false},
+       {{-90, 180, 0}, "up",  true,  true, false},
+       {{ 90, 180, 0}, "dn",  true,  true, false},
+
+       {{  0,   0, 0}, "px",  true,  true,  true},
+       {{  0,  90, 0}, "py", false,  true, false},
+       {{  0, 180, 0}, "nx", false, false,  true},
+       {{  0, 270, 0}, "ny",  true, false, false},
+       {{-90, 180, 0}, "pz", false, false,  true},
+       {{ 90, 180, 0}, "nz", false, false,  true}
 };
 
 static void R_Envmap_f (void)
 {
        int j, size;
-       char filename[256], basename[256];
+       char filename[MAX_QPATH], basename[MAX_QPATH];
+       unsigned char *buffer1;
+       unsigned char *buffer2;
+       unsigned char *buffer3;
 
        if (Cmd_Argc() != 3)
        {
@@ -747,7 +1219,7 @@ static void R_Envmap_f (void)
                Con_Print("envmap: size must be one of 128, 256, 512, or 1024\n");
                return;
        }
-       if (size > vid.realwidth || size > vid.realheight)
+       if (size > vid.width || size > vid.height)
        {
                Con_Print("envmap: your resolution is not big enough to render that size\n");
                return;
@@ -760,18 +1232,28 @@ static void R_Envmap_f (void)
        r_refdef.width = size;
        r_refdef.height = size;
 
-       r_refdef.fov_x = 90;
-       r_refdef.fov_y = 90;
+       r_refdef.frustum_x = tan(90 * M_PI / 360.0);
+       r_refdef.frustum_y = tan(90 * M_PI / 360.0);
+
+       buffer1 = (unsigned char *)Mem_Alloc(tempmempool, size * size * 3);
+       buffer2 = (unsigned char *)Mem_Alloc(tempmempool, size * size * 3);
+       buffer3 = (unsigned char *)Mem_Alloc(tempmempool, size * size * 3 + 18);
 
-       for (j = 0;j < 6;j++)
+       for (j = 0;j < 12;j++)
        {
                sprintf(filename, "env/%s%s.tga", basename, envmapinfo[j].name);
                Matrix4x4_CreateFromQuakeEntity(&r_refdef.viewentitymatrix, r_vieworigin[0], r_vieworigin[1], r_vieworigin[2], envmapinfo[j].angles[0], envmapinfo[j].angles[1], envmapinfo[j].angles[2], 1);
                R_ClearScreen();
+               R_Mesh_Start();
                R_RenderView();
-               SCR_ScreenShot(filename, vid.realx, vid.realy + vid.realheight - (r_refdef.y + r_refdef.height), size, size, false);
+               R_Mesh_Finish();
+               SCR_ScreenShot(filename, buffer1, buffer2, buffer3, 0, vid.height - (r_refdef.y + r_refdef.height), size, size, envmapinfo[j].flipx, envmapinfo[j].flipy, envmapinfo[j].flipdiagonaly, false, false);
        }
 
+       Mem_Free (buffer1);
+       Mem_Free (buffer2);
+       Mem_Free (buffer3);
+
        envmap = false;
 }
 
@@ -794,7 +1276,7 @@ showlmp_t showlmp[SHOWLMP_MAXLABELS];
 void SHOWLMP_decodehide(void)
 {
        int i;
-       qbyte *lmplabel;
+       char *lmplabel;
        lmplabel = MSG_ReadString();
        for (i = 0;i < SHOWLMP_MAXLABELS;i++)
                if (showlmp[i].isactive && strcmp(showlmp[i].label, lmplabel) == 0)
@@ -807,7 +1289,7 @@ void SHOWLMP_decodehide(void)
 void SHOWLMP_decodeshow(void)
 {
        int i, k;
-       qbyte lmplabel[256], picname[256];
+       char lmplabel[256], picname[256];
        float x, y;
        strlcpy (lmplabel,MSG_ReadString(), sizeof (lmplabel));
        strlcpy (picname, MSG_ReadString(), sizeof (picname));
@@ -862,8 +1344,6 @@ void CL_SetupScreenSize(void)
 {
        float conwidth, conheight;
 
-       VID_GetWindowSize (&vid.realx, &vid.realy, &vid.realwidth, &vid.realheight);
-
        VID_UpdateGamma(false);
 
        conwidth = bound(320, vid_conwidth.value, 2048);
@@ -873,16 +1353,8 @@ void CL_SetupScreenSize(void)
        if (vid_conheight.value != conheight)
                Cvar_SetValue("vid_conheight", conheight);
 
-       vid.conwidth = vid_conwidth.integer;
-       vid.conheight = vid_conheight.integer;
-
-/*     if (vid.realheight > 240)
-       {
-               vid.conheight = (vid.realheight - 240) * scr_2dresolution.value + 240;
-               vid.conheight = bound(240, vid.conheight, vid.realheight);
-       }
-       else
-               vid.conheight = 240;*/
+       vid_conwidth.integer = vid_conwidth.integer;
+       vid_conheight.integer = vid_conheight.integer;
 
        SCR_SetUpToDrawConsole();
 }
@@ -893,10 +1365,45 @@ void CL_UpdateScreen(void)
        if (!scr_initialized || !con_initialized || vid_hidden)
                return;                         // not initialized yet
 
-       if (cl_avidemo.integer)
-               SCR_CaptureAVIDemo();
+       // don't allow cheats in multiplayer
+       if (!cl.islocalgame && cl.worldmodel)
+       {
+               if (r_fullbright.integer != 0)
+                       Cvar_Set ("r_fullbright", "0");
+               if (r_ambient.value != 0)
+                       Cvar_Set ("r_ambient", "0");
+       }
+
+       // bound viewsize
+       if (scr_viewsize.value < 30)
+               Cvar_Set ("viewsize","30");
+       if (scr_viewsize.value > 120)
+               Cvar_Set ("viewsize","120");
+
+       // bound field of view
+       if (scr_fov.value < 1)
+               Cvar_Set ("fov","1");
+       if (scr_fov.value > 170)
+               Cvar_Set ("fov","170");
+
+       // intermission is always full screen
+       if (cl.intermission)
+               sb_lines = 0;
        else
-               cl_avidemo_frame = 0;
+       {
+               if (scr_viewsize.value >= 120)
+                       sb_lines = 0;           // no status bar at all
+               else if (scr_viewsize.value >= 110)
+                       sb_lines = 24;          // no inventory
+               else
+                       sb_lines = 24+16+8;
+       }
+
+       r_refdef.colormask[0] = 1;
+       r_refdef.colormask[1] = 1;
+       r_refdef.colormask[2] = 1;
+
+       SCR_CaptureVideo();
 
        if (cls.signon == SIGNONS)
                R_TimeReport("other");
@@ -911,36 +1418,32 @@ void CL_UpdateScreen(void)
        //FIXME: force menu if nothing else to look at?
        //if (key_dest == key_game && cls.signon != SIGNONS && cls.state == ca_disconnected)
 
-       if (scr_drawloading)
+       if (cls.signon == SIGNONS)
        {
-               scr_drawloading = false;
-               SCR_DrawLoading();
+               SCR_DrawNet ();
+               SCR_DrawTurtle ();
+               SCR_DrawPause ();
+               if (!r_letterbox.value)
+                       Sbar_Draw();
+               SHOWLMP_drawall();
+               SCR_CheckDrawCenterString();
        }
-       else
+       MR_Draw();
+       UI_Callback_Draw();
+       CL_DrawVideo();
+       //ui_draw();
+       if (cls.signon == SIGNONS)
        {
-               if (cls.signon == SIGNONS)
-               {
-                       SCR_DrawNet ();
-                       SCR_DrawTurtle ();
-                       SCR_DrawPause ();
-                       Sbar_Draw();
-                       SHOWLMP_drawall();
-                       SCR_CheckDrawCenterString();
-               }
-               MR_Draw();
-               UI_Callback_Draw();
-               CL_DrawVideo();
-               //ui_draw();
-               if (cls.signon == SIGNONS)
-               {
-                       R_TimeReport("2d");
-                       R_TimeReport_End();
-                       R_TimeReport_Start();
-               }
-               R_Shadow_EditLights_DrawSelectedLightProperties();
+               R_TimeReport("2d");
+               R_TimeReport_End();
+               R_TimeReport_Start();
        }
+       R_Shadow_EditLights_DrawSelectedLightProperties();
+
        SCR_DrawConsole();
 
+       SCR_DrawBrand();
+
        SCR_UpdateScreen();
 }
 
@@ -948,4 +1451,3 @@ void CL_Screen_NewMap(void)
 {
        SHOWLMP_clear();
 }
-