cl_screen.c

   1
   2 #include "quakedef.h"
   3
   4 cvar_t scr_viewsize = {CVAR_SAVE, "viewsize","100"};
   5 cvar_t scr_fov = {CVAR_SAVE, "fov","90"};       // 10 - 170
   6 cvar_t scr_conspeed = {CVAR_SAVE, "scr_conspeed","900"}; // LordHavoc: quake used 300
   7 cvar_t scr_centertime = {0, "scr_centertime","2"};
   8 cvar_t scr_showram = {CVAR_SAVE, "showram","1"};
   9 cvar_t scr_showturtle = {CVAR_SAVE, "showturtle","0"};
  10 cvar_t scr_showpause = {CVAR_SAVE, "showpause","1"};
  11 cvar_t scr_printspeed = {0, "scr_printspeed","8"};
  12 cvar_t scr_2dresolution = {CVAR_SAVE, "scr_2dresolution", "1"};
  13 cvar_t cl_avidemo = {0, "cl_avidemo", "0"};
  14
  15 qboolean        scr_initialized;                // ready to draw
  16
  17 float           scr_con_current;
  18 float           scr_conlines;           // lines of console to display
  19
  20 int                     clearconsole;
  21 int                     clearnotify;
  22
  23 //qboolean      scr_disabled_for_loading;
  24 qboolean        scr_drawloading = false;
  25 //float         scr_disabled_time;
  26
  27 static qbyte menuplyr_pixels[4096];
  28
  29 void DrawCrosshair(int num);
  30 void V_CalcRefdef (void);
  31 static void SCR_ScreenShot_f (void);
  32 static void R_Envmap_f (void);
  33
  34 // backend
  35 void R_ClearScreen(void);
  36
  37 /*
  38 ===============================================================================
  39
  40 CENTER PRINTING
  41
  42 ===============================================================================
  43 */
  44
  45 char            scr_centerstring[1024];
  46 float           scr_centertime_start;   // for slow victory printing
  47 float           scr_centertime_off;
  48 int                     scr_center_lines;
  49 int                     scr_erase_lines;
  50 int                     scr_erase_center;
  51
  52 /*
  53 ==============
  54 SCR_CenterPrint
  55
  56 Called for important messages that should stay in the center of the screen
  57 for a few moments
  58 ==============
  59 */
  60 void SCR_CenterPrint (char *str)
  61 {
  62         strncpy (scr_centerstring, str, sizeof(scr_centerstring)-1);
  63         scr_centertime_off = scr_centertime.value;
  64         scr_centertime_start = cl.time;
  65
  66 // count the number of lines for centering
  67         scr_center_lines = 1;
  68         while (*str)
  69         {
  70                 if (*str == '\n')
  71                         scr_center_lines++;
  72                 str++;
  73         }
  74 }
  75
  76
  77 void SCR_DrawCenterString (void)
  78 {
  79         char    *start;
  80         int             l;
  81         int             x, y;
  82         int             remaining;
  83
  84 // the finale prints the characters one at a time
  85         if (cl.intermission)
  86                 remaining = scr_printspeed.value * (cl.time - scr_centertime_start);
  87         else
  88                 remaining = 9999;
  89
  90         scr_erase_center = 0;
  91         start = scr_centerstring;
  92
  93         if (scr_center_lines <= 4)
  94                 y = vid.conheight*0.35;
  95         else
  96                 y = 48;
  97
  98         do
  99         {
 100         // scan the width of the line
 101                 for (l=0 ; l<40 ; l++)
 102                         if (start[l] == '\n' || !start[l])
 103                                 break;
 104                 x = (vid.conwidth - l*8)/2;
 105                 if (l > 0)
 106                 {
 107                         if (remaining < l)
 108                                 l = remaining;
 109                         DrawQ_String(x, y, start, l, 8, 8, 1, 1, 1, 1, 0);
 110                         remaining -= l;
 111                         if (remaining <= 0)
 112                                 return;
 113                 }
 114
 115                 y += 8;
 116
 117                 while (*start && *start != '\n')
 118                         start++;
 119
 120                 if (!*start)
 121                         break;
 122                 start++;                // skip the \n
 123         } while (1);
 124 }
 125
 126 void SCR_CheckDrawCenterString (void)
 127 {
 128         if (scr_center_lines > scr_erase_lines)
 129                 scr_erase_lines = scr_center_lines;
 130
 131         scr_centertime_off -= host_frametime;
 132
 133         // don't draw if this is a normal stats-screen intermission,
 134         // only if it is not an intermission, or a finale intermission
 135         if (cl.intermission == 1)
 136                 return;
 137         if (scr_centertime_off <= 0 && !cl.intermission)
 138                 return;
 139         if (key_dest != key_game)
 140                 return;
 141
 142         SCR_DrawCenterString ();
 143 }
 144
 145 /*
 146 ==============
 147 SCR_DrawRam
 148 ==============
 149 */
 150 void SCR_DrawRam (void)
 151 {
 152 //      if (!scr_showram.integer)
 153 //              return;
 154 //      DrawQ_Pic (32, 0, "ram", 0, 0, 1, 1, 1, 1, 0);
 155 }
 156
 157 /*
 158 ==============
 159 SCR_DrawTurtle
 160 ==============
 161 */
 162 void SCR_DrawTurtle (void)
 163 {
 164         static int      count;
 165
 166         if (cls.state != ca_connected)
 167                 return;
 168
 169         if (!scr_showturtle.integer)
 170                 return;
 171
 172         if (host_frametime < 0.1)
 173         {
 174                 count = 0;
 175                 return;
 176         }
 177
 178         count++;
 179         if (count < 3)
 180                 return;
 181
 182         DrawQ_Pic (0, 0, "turtle", 0, 0, 1, 1, 1, 1, 0);
 183 }
 184
 185 /*
 186 ==============
 187 SCR_DrawNet
 188 ==============
 189 */
 190 void SCR_DrawNet (void)
 191 {
 192         if (cls.state != ca_connected)
 193                 return;
 194         if (realtime - cl.last_received_message < 0.3)
 195                 return;
 196         if (cls.demoplayback)
 197                 return;
 198
 199         DrawQ_Pic (64, 0, "net", 0, 0, 1, 1, 1, 1, 0);
 200 }
 201
 202 /*
 203 ==============
 204 DrawPause
 205 ==============
 206 */
 207 void SCR_DrawPause (void)
 208 {
 209         cachepic_t      *pic;
 210
 211         if (cls.state != ca_connected)
 212                 return;
 213
 214         if (!scr_showpause.integer)             // turn off for screenshots
 215                 return;
 216
 217         if (!cl.paused)
 218                 return;
 219
 220         pic = Draw_CachePic ("gfx/pause.lmp");
 221         DrawQ_Pic ((vid.conwidth - pic->width)/2, (vid.conheight - pic->height)/2, "gfx/pause.lmp", 0, 0, 1, 1, 1, 1, 0);
 222 }
 223
 224
 225
 226 /*
 227 ==============
 228 SCR_DrawLoading
 229 ==============
 230 */
 231 void SCR_DrawLoading (void)
 232 {
 233         cachepic_t      *pic;
 234
 235         //if (!scr_drawloading)
 236         //      return;
 237
 238         pic = Draw_CachePic ("gfx/loading.lmp");
 239         DrawQ_Pic ((vid.conwidth - pic->width)/2, (vid.conheight - pic->height)/2, "gfx/loading.lmp", 0, 0, 1, 1, 1, 1, 0);
 240 }
 241
 242
 243
 244 //=============================================================================
 245
 246
 247 /*
 248 ==================
 249 SCR_SetUpToDrawConsole
 250 ==================
 251 */
 252 void SCR_SetUpToDrawConsole (void)
 253 {
 254         Con_CheckResize ();
 255
 256 // decide on the height of the console
 257         con_forcedup = !cl.worldmodel || cls.signon != SIGNONS;
 258
 259         if (con_forcedup)
 260         {
 261                 scr_conlines = vid.conheight;           // full screen
 262                 scr_con_current = scr_conlines;
 263         }
 264         else if (key_dest == key_console)
 265                 scr_conlines = vid.conheight/2; // half screen
 266         else
 267                 scr_conlines = 0;                               // none visible
 268
 269         if (scr_conlines < scr_con_current)
 270         {
 271                 scr_con_current -= scr_conspeed.value*host_realframetime;
 272                 if (scr_conlines > scr_con_current)
 273                         scr_con_current = scr_conlines;
 274
 275         }
 276         else if (scr_conlines > scr_con_current)
 277         {
 278                 scr_con_current += scr_conspeed.value*host_realframetime;
 279                 if (scr_conlines < scr_con_current)
 280                         scr_con_current = scr_conlines;
 281         }
 282 }
 283
 284 /*
 285 ==================
 286 SCR_DrawConsole
 287 ==================
 288 */
 289 void SCR_DrawConsole (void)
 290 {
 291         if (scr_con_current)
 292         {
 293                 Con_DrawConsole (scr_con_current);
 294                 clearconsole = 0;
 295         }
 296         else
 297         {
 298                 if (key_dest == key_game || key_dest == key_message)
 299                         Con_DrawNotify ();      // only draw notify in game
 300         }
 301 }
 302
 303 /*
 304 ===============
 305 SCR_BeginLoadingPlaque
 306
 307 ================
 308 */
 309 void SCR_BeginLoadingPlaque (void)
 310 {
 311         if (scr_drawloading)
 312                 return;
 313
 314         S_StopAllSounds (true);
 315
 316 //      if (cls.state != ca_connected)
 317 //              return;
 318 //      if (cls.signon != SIGNONS)
 319 //              return;
 320
 321 // redraw with no console and the loading plaque
 322 //      Con_ClearNotify ();
 323 //      scr_centertime_off = 0;
 324 //      scr_con_current = 0;
 325
 326         scr_drawloading = true;
 327         CL_UpdateScreen ();
 328         scr_drawloading = true;
 329         CL_UpdateScreen ();
 330         //scr_drawloading = false;
 331
 332 //      scr_disabled_for_loading = true;
 333 //      scr_disabled_time = realtime;
 334 }
 335
 336 /*
 337 ===============
 338 SCR_EndLoadingPlaque
 339
 340 ================
 341 */
 342 void SCR_EndLoadingPlaque (void)
 343 {
 344         /*
 345         if (!scr_drawloading)
 346                 return;
 347
 348 //      scr_disabled_for_loading = false;
 349         scr_drawloading = false;
 350         Con_ClearNotify ();
 351         */
 352 }
 353
 354 //=============================================================================
 355
 356 char r_speeds_string[1024];
 357 int speedstringcount, r_timereport_active;
 358 double r_timereport_temp = 0, r_timereport_current = 0, r_timereport_start = 0;
 359
 360 void R_TimeReport(char *desc)
 361 {
 362         char tempbuf[256];
 363         int length;
 364         int t;
 365
 366         if (!r_timereport_active)
 367                 return;
 368
 369         r_timereport_temp = r_timereport_current;
 370         r_timereport_current = Sys_DoubleTime();
 371         t = (int) ((r_timereport_current - r_timereport_temp) * 1000000.0);
 372
 373         sprintf(tempbuf, "%8i %s", t, desc);
 374         length = strlen(tempbuf);
 375         while (length < 20)
 376                 tempbuf[length++] = ' ';
 377         tempbuf[length] = 0;
 378         if (speedstringcount + length > (vid.conwidth / 8))
 379         {
 380                 strcat(r_speeds_string, "\n");
 381                 speedstringcount = 0;
 382         }
 383         // skip the space at the beginning if it's the first on the line
 384         if (speedstringcount == 0)
 385         {
 386                 strcat(r_speeds_string, tempbuf + 1);
 387                 speedstringcount = length - 1;
 388         }
 389         else
 390         {
 391                 strcat(r_speeds_string, tempbuf);
 392                 speedstringcount += length;
 393         }
 394 }
 395
 396 void R_TimeReport_Start(void)
 397 {
 398         r_timereport_active = r_speeds.integer && cl.worldmodel && cls.state == ca_connected;
 399         r_speeds_string[0] = 0;
 400         if (r_timereport_active)
 401         {
 402                 speedstringcount = 0;
 403                 AngleVectors (r_refdef.viewangles, vpn, NULL, NULL);
 404                 //sprintf(r_speeds_string, "org:'%c%6.2f %c%6.2f %c%6.2f' ang:'%c%3.0f %c%3.0f %c%3.0f' dir:'%c%2.3f %c%2.3f %c%2.3f'\n%6i walls %6i dlitwalls %7i modeltris %7i meshtris\nBSP: %6i faces %6i nodes %6i leafs\n%4i models %4i bmodels %4i sprites %5i particles %3i dlights\n",
 405                 //      r_refdef.vieworg[0] < 0 ? '-' : ' ', fabs(r_refdef.vieworg[0]), r_refdef.vieworg[1] < 0 ? '-' : ' ', fabs(r_refdef.vieworg[1]), r_refdef.vieworg[2] < 0 ? '-' : ' ', fabs(r_refdef.vieworg[2]),
 406                 //      r_refdef.viewangles[0] < 0 ? '-' : ' ', fabs(r_refdef.viewangles[0]), r_refdef.viewangles[1] < 0 ? '-' : ' ', fabs(r_refdef.viewangles[1]), r_refdef.viewangles[2] < 0 ? '-' : ' ', fabs(r_refdef.viewangles[2]),
 407                 //      vpn[0] < 0 ? '-' : ' ', fabs(vpn[0]), vpn[1] < 0 ? '-' : ' ', fabs(vpn[1]), vpn[2] < 0 ? '-' : ' ', fabs(vpn[2]),
 408                 sprintf(r_speeds_string,
 409                         "org:'%+8.2f %+8.2f %+8.2f' ang:'%+4.0f %+4.0f %+4.0f' dir:'%+2.3f %+2.3f %+2.3f'\n"
 410                         "world:%6i faces%6i nodes%6i leafs%6i walls%6i dlitwalls\n"
 411                         "%5i models%5i bmodels%5i sprites%6i particles%4i dlights\n"
 412                         "%6i modeltris%6i transmeshs%6i transtris%6i meshs%6i meshtris\n",
 413                         r_refdef.vieworg[0], r_refdef.vieworg[1], r_refdef.vieworg[2], r_refdef.viewangles[0], r_refdef.viewangles[1], r_refdef.viewangles[2], vpn[0], vpn[1], vpn[2],
 414                         c_faces, c_nodes, c_leafs, c_brush_polys, c_light_polys,
 415                         c_models, c_bmodels, c_sprites, c_particles, c_dlights,
 416                         c_alias_polys, c_transmeshs, c_transtris, c_meshs, c_meshtris);
 417
 418                 c_brush_polys = 0;
 419                 c_alias_polys = 0;
 420                 c_light_polys = 0;
 421                 c_faces = 0;
 422                 c_nodes = 0;
 423                 c_leafs = 0;
 424                 c_models = 0;
 425                 c_bmodels = 0;
 426                 c_sprites = 0;
 427                 c_particles = 0;
 428         //      c_dlights = 0;
 429
 430                 r_timereport_start = Sys_DoubleTime();
 431         }
 432 }
 433
 434 void R_TimeReport_End(void)
 435 {
 436         r_timereport_current = r_timereport_start;
 437         R_TimeReport("total");
 438
 439         if (r_timereport_active)
 440         {
 441                 int i, j, lines, y;
 442                 lines = 1;
 443                 for (i = 0;r_speeds_string[i];i++)
 444                         if (r_speeds_string[i] == '\n')
 445                                 lines++;
 446                 y = vid.conheight - sb_lines - lines * 8/* - 8*/;
 447                 i = j = 0;
 448                 DrawQ_Fill(0, y, vid.conwidth, lines * 8, 0, 0, 0, 0.5, 0);
 449                 while (r_speeds_string[i])
 450                 {
 451                         j = i;
 452                         while (r_speeds_string[i] && r_speeds_string[i] != '\n')
 453                                 i++;
 454                         if (i - j > 0)
 455                                 DrawQ_String(0, y, r_speeds_string + j, i - j, 8, 8, 1, 1, 1, 1, 0);
 456                         if (r_speeds_string[i] == '\n')
 457                                 i++;
 458                         y += 8;
 459                 }
 460         }
 461 }
 462
 463 /*
 464 =================
 465 SCR_SizeUp_f
 466
 467 Keybinding command
 468 =================
 469 */
 470 void SCR_SizeUp_f (void)
 471 {
 472         Cvar_SetValue ("viewsize",scr_viewsize.value+10);
 473 }
 474
 475
 476 /*
 477 =================
 478 SCR_SizeDown_f
 479
 480 Keybinding command
 481 =================
 482 */
 483 void SCR_SizeDown_f (void)
 484 {
 485         Cvar_SetValue ("viewsize",scr_viewsize.value-10);
 486 }
 487
 488 void CL_Screen_Init(void)
 489 {
 490         qpic_t *dat;
 491
 492         Cvar_RegisterVariable (&scr_fov);
 493         Cvar_RegisterVariable (&scr_viewsize);
 494         Cvar_RegisterVariable (&scr_conspeed);
 495         Cvar_RegisterVariable (&scr_showram);
 496         Cvar_RegisterVariable (&scr_showturtle);
 497         Cvar_RegisterVariable (&scr_showpause);
 498         Cvar_RegisterVariable (&scr_centertime);
 499         Cvar_RegisterVariable (&scr_printspeed);
 500         Cvar_RegisterVariable (&scr_2dresolution);
 501         Cvar_RegisterVariable (&cl_avidemo);
 502
 503         Cmd_AddCommand ("sizeup",SCR_SizeUp_f);
 504         Cmd_AddCommand ("sizedown",SCR_SizeDown_f);
 505         Cmd_AddCommand ("screenshot",SCR_ScreenShot_f);
 506         Cmd_AddCommand ("envmap", R_Envmap_f);
 507
 508         scr_initialized = true;
 509
 510         // HACK HACK HACK
 511         // load the image data for the player image in the config menu
 512         dat = (qpic_t *)COM_LoadFile ("gfx/menuplyr.lmp", false);
 513         if (!dat)
 514                 Sys_Error("unable to load gfx/menuplyr.lmp");
 515         SwapPic (dat);
 516
 517         if (dat->width*dat->height <= 4096)
 518                 memcpy (menuplyr_pixels, dat->data, dat->width * dat->height);
 519         else
 520                 Con_Printf("gfx/menuplyr.lmp larger than 4k buffer");
 521         Mem_Free(dat);
 522 }
 523
 524 void DrawQ_Clear(void)
 525 {
 526         r_refdef.drawqueuesize = 0;
 527 }
 528
 529 void DrawQ_Pic(float x, float y, char *picname, float width, float height, float red, float green, float blue, float alpha, int flags)
 530 {
 531         int size;
 532         drawqueue_t *dq;
 533         if (alpha < (1.0f / 255.0f))
 534                 return;
 535         size = sizeof(*dq) + ((strlen(picname) + 1 + 3) & ~3);
 536         if (r_refdef.drawqueuesize + size > MAX_DRAWQUEUE)
 537                 return;
 538         red = bound(0, red, 1);
 539         green = bound(0, green, 1);
 540         blue = bound(0, blue, 1);
 541         alpha = bound(0, alpha, 1);
 542         dq = (void *)(r_refdef.drawqueue + r_refdef.drawqueuesize);
 543         dq->size = size;
 544         dq->command = DRAWQUEUE_PIC;
 545         dq->flags = flags;
 546         dq->color = ((unsigned int) (red * 255.0f) << 24) | ((unsigned int) (green * 255.0f) << 16) | ((unsigned int) (blue * 255.0f) << 8) | ((unsigned int) (alpha * 255.0f));
 547         dq->x = x;
 548         dq->y = y;
 549         // if these are not zero, they override the pic's size
 550         dq->scalex = width;
 551         dq->scaley = height;
 552         strcpy((char *)(dq + 1), picname);
 553         r_refdef.drawqueuesize += dq->size;
 554 }
 555
 556 void DrawQ_String(float x, float y, char *string, int maxlen, float scalex, float scaley, float red, float green, float blue, float alpha, int flags)
 557 {
 558         int size, len;
 559         drawqueue_t *dq;
 560         char *out;
 561         if (alpha < (1.0f / 255.0f))
 562                 return;
 563         if (maxlen < 1)
 564                 len = strlen(string);
 565         else
 566                 for (len = 0;len < maxlen && string[len];len++);
 567         for (;len > 0 && string[0] == ' ';string++, x += scalex, len--);
 568         for (;len > 0 && string[len - 1] == ' ';len--);
 569         if (len < 1)
 570                 return;
 571         if (x >= vid.conwidth || y >= vid.conheight || x < (-scalex * maxlen) || y < (-scaley))
 572                 return;
 573         size = sizeof(*dq) + ((len + 1 + 3) & ~3);
 574         if (r_refdef.drawqueuesize + size > MAX_DRAWQUEUE)
 575                 return;
 576         red = bound(0, red, 1);
 577         green = bound(0, green, 1);
 578         blue = bound(0, blue, 1);
 579         alpha = bound(0, alpha, 1);
 580         dq = (void *)(r_refdef.drawqueue + r_refdef.drawqueuesize);
 581         dq->size = size;
 582         dq->command = DRAWQUEUE_STRING;
 583         dq->flags = flags;
 584         dq->color = ((unsigned int) (red * 255.0f) << 24) | ((unsigned int) (green * 255.0f) << 16) | ((unsigned int) (blue * 255.0f) << 8) | ((unsigned int) (alpha * 255.0f));
 585         dq->x = x;
 586         dq->y = y;
 587         dq->scalex = scalex;
 588         dq->scaley = scaley;
 589         out = (char *)(dq + 1);
 590         memcpy(out, string, len);
 591         out[len] = 0;
 592         r_refdef.drawqueuesize += dq->size;
 593 }
 594
 595 void DrawQ_Fill (float x, float y, float w, float h, float red, float green, float blue, float alpha, int flags)
 596 {
 597         int size;
 598         drawqueue_t *dq;
 599         if (alpha < (1.0f / 255.0f))
 600                 return;
 601         size = sizeof(*dq) + 4;
 602         if (r_refdef.drawqueuesize + size > MAX_DRAWQUEUE)
 603                 return;
 604         red = bound(0, red, 1);
 605         green = bound(0, green, 1);
 606         blue = bound(0, blue, 1);
 607         alpha = bound(0, alpha, 1);
 608         dq = (void *)(r_refdef.drawqueue + r_refdef.drawqueuesize);
 609         dq->size = size;
 610         dq->command = DRAWQUEUE_PIC;
 611         dq->flags = flags;
 612         dq->color = ((unsigned int) (red * 255.0f) << 24) | ((unsigned int) (green * 255.0f) << 16) | ((unsigned int) (blue * 255.0f) << 8) | ((unsigned int) (alpha * 255.0f));
 613         dq->x = x;
 614         dq->y = y;
 615         dq->scalex = w;
 616         dq->scaley = h;
 617         // empty pic name
 618         *((char *)(dq + 1)) = 0;
 619         r_refdef.drawqueuesize += dq->size;
 620 }
 621
 622 //only used for the player color selection menu
 623 void DrawQ_PicTranslate (int x, int y, char *picname, qbyte *translation)
 624 {
 625         int i, c;
 626         unsigned int trans[4096];
 627         cachepic_t *pic;
 628
 629         pic = Draw_CachePic(picname);
 630         if (pic == NULL)
 631                 return;
 632
 633         c = pic->width * pic->height;
 634         if (c > 4096)
 635         {
 636                 Con_Printf("DrawQ_PicTranslate: image larger than 4k buffer\n");
 637                 return;
 638         }
 639
 640         for (i = 0;i < c;i++)
 641                 trans[i] = d_8to24table[translation[menuplyr_pixels[i]]];
 642
 643         // FIXME: this is renderer stuff?
 644         R_UpdateTexture (pic->tex, (qbyte *)trans);
 645
 646         DrawQ_Pic(x, y, picname, 0, 0, 1, 1, 1, 1, 0);
 647 }
 648
 649
 650 /*
 651 ====================
 652 CalcFov
 653 ====================
 654 */
 655 float CalcFov (float fov_x, float width, float height)
 656 {
 657         // calculate vision size and alter by aspect, then convert back to angle
 658         return atan (height / (width / tan(fov_x/360*M_PI))) * 360 / M_PI;
 659 }
 660
 661 /*
 662 =================
 663 SCR_CalcRefdef
 664
 665 Must be called whenever vid changes
 666 Internal use only
 667 =================
 668 */
 669 static void SCR_CalcRefdef (void)
 670 {
 671         float size;
 672         int contents;
 673
 674 //========================================
 675
 676 // bound viewsize
 677         if (scr_viewsize.value < 30)
 678                 Cvar_Set ("viewsize","30");
 679         if (scr_viewsize.value > 120)
 680                 Cvar_Set ("viewsize","120");
 681
 682 // bound field of view
 683         if (scr_fov.value < 10)
 684                 Cvar_Set ("fov","10");
 685         if (scr_fov.value > 170)
 686                 Cvar_Set ("fov","170");
 687
 688 // intermission is always full screen
 689         if (cl.intermission)
 690         {
 691                 size = 1;
 692                 sb_lines = 0;
 693         }
 694         else
 695         {
 696                 if (scr_viewsize.value >= 120)
 697                         sb_lines = 0;           // no status bar at all
 698                 else if (scr_viewsize.value >= 110)
 699                         sb_lines = 24;          // no inventory
 700                 else
 701                         sb_lines = 24+16+8;
 702                 size = scr_viewsize.value * (1.0 / 100.0);
 703         }
 704
 705         if (size >= 1)
 706         {
 707                 r_refdef.width = vid.realwidth;
 708                 r_refdef.height = vid.realheight;
 709                 r_refdef.x = 0;
 710                 r_refdef.y = 0;
 711         }
 712         else
 713         {
 714                 r_refdef.width = vid.realwidth * size;
 715                 r_refdef.height = vid.realheight * size;
 716                 r_refdef.x = (vid.realwidth - r_refdef.width)/2;
 717                 r_refdef.y = (vid.realheight - r_refdef.height)/2;
 718         }
 719
 720         r_refdef.width = bound(0, r_refdef.width, vid.realwidth);
 721         r_refdef.height = bound(0, r_refdef.height, vid.realheight);
 722         r_refdef.x = bound(0, r_refdef.x, vid.realwidth - r_refdef.width) + vid.realx;
 723         r_refdef.y = bound(0, r_refdef.y, vid.realheight - r_refdef.height) + vid.realy;
 724
 725         // LordHavoc: viewzoom (zoom in for sniper rifles, etc)
 726         r_refdef.fov_x = scr_fov.value * cl.viewzoom;
 727         r_refdef.fov_y = CalcFov (r_refdef.fov_x, r_refdef.width, r_refdef.height);
 728
 729         if (cl.worldmodel)
 730         {
 731                 Mod_CheckLoaded(cl.worldmodel);
 732                 contents = Mod_PointInLeaf(r_refdef.vieworg, cl.worldmodel)->contents;
 733                 if (contents != CONTENTS_EMPTY && contents != CONTENTS_SOLID)
 734                 {
 735                         r_refdef.fov_x *= (sin(cl.time * 4.7) * 0.015 + 0.985);
 736                         r_refdef.fov_y *= (sin(cl.time * 3.0) * 0.015 + 0.985);
 737                 }
 738         }
 739 }
 740
 741 /*
 742 ==================
 743 SCR_ScreenShot_f
 744 ==================
 745 */
 746 void SCR_ScreenShot_f (void)
 747 {
 748         int i;
 749         char filename[16];
 750         char checkname[MAX_OSPATH];
 751 //
 752 // find a file name to save it to
 753 //
 754         strcpy(filename, "dp0000.tga");
 755
 756         for (i=0 ; i<=9999 ; i++)
 757         {
 758                 filename[2] = (i/1000)%10 + '0';
 759                 filename[3] = (i/ 100)%10 + '0';
 760                 filename[4] = (i/  10)%10 + '0';
 761                 filename[5] = (i/   1)%10 + '0';
 762                 sprintf (checkname, "%s/%s", com_gamedir, filename);
 763                 if (Sys_FileTime(checkname) == -1)
 764                         break;  // file doesn't exist
 765         }
 766         if (i==10000)
 767         {
 768                 Con_Printf ("SCR_ScreenShot_f: Couldn't create a TGA file\n");
 769                 return;
 770         }
 771
 772         if (SCR_ScreenShot(filename, vid.realx, vid.realy, vid.realwidth, vid.realheight))
 773                 Con_Printf ("Wrote %s\n", filename);
 774         else
 775                 Con_Printf ("unable to write %s\n", filename);
 776 }
 777
 778 static int cl_avidemo_frame = 0;
 779
 780 void SCR_CaptureAVIDemo(void)
 781 {
 782         char filename[32];
 783         sprintf(filename, "dpavi%06d.tga", cl_avidemo_frame);
 784         if (SCR_ScreenShot(filename, vid.realx, vid.realy, vid.realwidth, vid.realheight))
 785                 cl_avidemo_frame++;
 786         else
 787         {
 788                 Cvar_SetValueQuick(&cl_avidemo, 0);
 789                 Con_Printf("avi saving failed on frame %i, out of disk space?  stopping avi demo catpure.\n", cl_avidemo_frame);
 790                 cl_avidemo_frame = 0;
 791         }
 792 }
 793
 794 /*
 795 ===============
 796 R_Envmap_f
 797
 798 Grab six views for environment mapping tests
 799 ===============
 800 */
 801 struct
 802 {
 803         float angles[3];
 804         char *name;
 805 }
 806 envmapinfo[6] =
 807 {
 808         {{  0,   0, 0}, "ft"},
 809         {{  0,  90, 0}, "rt"},
 810         {{  0, 180, 0}, "bk"},
 811         {{  0, 270, 0}, "lf"},
 812         {{-90,  90, 0}, "up"},
 813         {{ 90,  90, 0}, "dn"}
 814 };
 815
 816 static void R_Envmap_f (void)
 817 {
 818         int j, size;
 819         char filename[256], basename[256];
 820
 821         if (Cmd_Argc() != 3)
 822         {
 823                 Con_Printf ("envmap <basename> <size>: save out 6 cubic environment map images, usable with loadsky, note that size must one of 128, 256, 512, or 1024 and can't be bigger than your current resolution\n");
 824                 return;
 825         }
 826
 827         strcpy(basename, Cmd_Argv(1));
 828         size = atoi(Cmd_Argv(2));
 829         if (size != 128 && size != 256 && size != 512 && size != 1024)
 830         {
 831                 Con_Printf("envmap: size must be one of 128, 256, 512, or 1024\n");
 832                 return;
 833         }
 834         if (size > vid.realwidth || size > vid.realheight)
 835         {
 836                 Con_Printf("envmap: your resolution is not big enough to render that size\n");
 837                 return;
 838         }
 839
 840         envmap = true;
 841
 842         r_refdef.x = 0;
 843         r_refdef.y = 0;
 844         r_refdef.width = size;
 845         r_refdef.height = size;
 846
 847         r_refdef.fov_x = 90;
 848         r_refdef.fov_y = 90;
 849
 850         for (j = 0;j < 6;j++)
 851         {
 852                 sprintf(filename, "env/%s%s.tga", basename, envmapinfo[j].name);
 853                 VectorCopy(envmapinfo[j].angles, r_refdef.viewangles);
 854                 R_ClearScreen();
 855                 R_RenderView ();
 856                 SCR_ScreenShot(filename, vid.realx, vid.realy, size, size);
 857         }
 858
 859         envmap = false;
 860 }
 861
 862 //=============================================================================
 863
 864 // LordHavoc: SHOWLMP stuff
 865 #define SHOWLMP_MAXLABELS 256
 866 typedef struct showlmp_s
 867 {
 868         qboolean        isactive;
 869         float           x;
 870         float           y;
 871         char            label[32];
 872         char            pic[128];
 873 }
 874 showlmp_t;
 875
 876 showlmp_t showlmp[SHOWLMP_MAXLABELS];
 877
 878 void SHOWLMP_decodehide(void)
 879 {
 880         int i;
 881         qbyte *lmplabel;
 882         lmplabel = MSG_ReadString();
 883         for (i = 0;i < SHOWLMP_MAXLABELS;i++)
 884                 if (showlmp[i].isactive && strcmp(showlmp[i].label, lmplabel) == 0)
 885                 {
 886                         showlmp[i].isactive = false;
 887                         return;
 888                 }
 889 }
 890
 891 void SHOWLMP_decodeshow(void)
 892 {
 893         int i, k;
 894         qbyte lmplabel[256], picname[256];
 895         float x, y;
 896         strcpy(lmplabel,MSG_ReadString());
 897         strcpy(picname, MSG_ReadString());
 898         if (gamemode == GAME_NEHAHRA) // LordHavoc: nasty old legacy junk
 899         {
 900                 x = MSG_ReadByte();
 901                 y = MSG_ReadByte();
 902         }
 903         else
 904         {
 905                 x = MSG_ReadShort();
 906                 y = MSG_ReadShort();
 907         }
 908         k = -1;
 909         for (i = 0;i < SHOWLMP_MAXLABELS;i++)
 910                 if (showlmp[i].isactive)
 911                 {
 912                         if (strcmp(showlmp[i].label, lmplabel) == 0)
 913                         {
 914                                 k = i;
 915                                 break; // drop out to replace it
 916                         }
 917                 }
 918                 else if (k < 0) // find first empty one to replace
 919                         k = i;
 920         if (k < 0)
 921                 return; // none found to replace
 922         // change existing one
 923         showlmp[k].isactive = true;
 924         strcpy(showlmp[k].label, lmplabel);
 925         strcpy(showlmp[k].pic, picname);
 926         showlmp[k].x = x;
 927         showlmp[k].y = y;
 928 }
 929
 930 void SHOWLMP_drawall(void)
 931 {
 932         int i;
 933         if (cl.worldmodel)
 934                 for (i = 0;i < SHOWLMP_MAXLABELS;i++)
 935                         if (showlmp[i].isactive)
 936                                 DrawQ_Pic(showlmp[i].x, showlmp[i].y, showlmp[i].pic, 0, 0, 1, 1, 1, 1, 0);
 937 }
 938
 939 void SHOWLMP_clear(void)
 940 {
 941         int i;
 942         for (i = 0;i < SHOWLMP_MAXLABELS;i++)
 943                 showlmp[i].isactive = false;
 944 }
 945
 946 void CL_SetupScreenSize(void)
 947 {
 948         static float old2dresolution = -1;
 949
 950         VID_GetWindowSize (&vid.realx, &vid.realy, &vid.realwidth, &vid.realheight);
 951
 952         VID_UpdateGamma(false);
 953
 954         if (scr_2dresolution.value != old2dresolution)
 955         {
 956                 Cvar_SetValue("scr_2dresolution", bound(0.0f, scr_2dresolution.value, 1.0f));
 957                 old2dresolution = scr_2dresolution.value;
 958         }
 959
 960         if (vid.realwidth > 320)
 961         {
 962                 vid.conwidth = (vid.realwidth - 320) * scr_2dresolution.value + 320;
 963                 vid.conwidth = bound(320, vid.conwidth, vid.realwidth);
 964         }
 965         else
 966                 vid.conwidth = 320;
 967
 968         if (vid.realheight > 240)
 969         {
 970                 vid.conheight = (vid.realheight - 240) * scr_2dresolution.value + 240;
 971                 vid.conheight = bound(240, vid.conheight, vid.realheight);
 972         }
 973         else
 974                 vid.conheight = 240;
 975
 976         SCR_SetUpToDrawConsole();
 977
 978         // determine size of refresh window
 979         SCR_CalcRefdef();
 980 }
 981
 982 void CL_UpdateScreen(void)
 983 {
 984         if (!scr_initialized || !con_initialized)
 985                 return;                         // not initialized yet
 986
 987         if (cl_avidemo.integer)
 988                 SCR_CaptureAVIDemo();
 989         else
 990                 cl_avidemo_frame = 0;
 991
 992         R_TimeReport("other");
 993
 994         CL_SetupScreenSize();
 995
 996         DrawQ_Clear();
 997
 998         V_UpdateBlends();
 999         V_CalcRefdef ();
1000
1001         R_TimeReport("setup");
1002
1003         SCR_DrawRam ();
1004         SCR_DrawNet ();
1005         SCR_DrawTurtle ();
1006         SCR_DrawPause ();
1007
1008         Sbar_Draw();
1009
1010         SCR_CheckDrawCenterString();
1011         SHOWLMP_drawall();
1012
1013         SCR_DrawConsole();
1014
1015         ui_draw();
1016
1017         if (scr_drawloading)
1018         {
1019                 scr_drawloading = false;
1020                 SCR_DrawLoading();
1021         }
1022
1023         R_TimeReport("2d");
1024
1025         // add r_speeds text to queue
1026         R_TimeReport_End();
1027
1028         // start a new timing run
1029         R_TimeReport_Start();
1030
1031         // make menu fade everything else on the screen
1032         M_Draw();
1033
1034         SCR_UpdateScreen();
1035 }
1036
1037 void CL_Screen_NewMap(void)
1038 {
1039         SHOWLMP_clear();
1040 }