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