Borland C++ compile fixes.
[xonotic/darkplaces.git] / gl_screen.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20
21 // screen.c -- master for refresh, status bar, console, chat, notify, etc
22
23 #include "quakedef.h"
24
25 /*
26
27 background clear
28 rendering
29 turtle/net/ram icons
30 sbar
31 centerprint / slow centerprint
32 notify lines
33 intermission / finale overlay
34 loading plaque
35 console
36 menu
37
38 required background clears
39 required update regions
40
41
42 syncronous draw mode or async
43 One off screen buffer, with updates either copied or xblited
44 Need to double buffer?
45
46
47 async draw will require the refresh area to be cleared, because it will be
48 xblited, but sync draw can just ignore it.
49
50 sync
51 draw
52
53 CenterPrint ()
54 SlowPrint ()
55 Screen_Update ();
56 Con_Printf ();
57
58 net 
59 turn off messages option
60
61 the refresh is allways rendered, unless the console is full screen
62
63
64 console is:
65         notify lines
66         half
67         full
68         
69
70 */
71
72
73 int                     glx, gly, glwidth, glheight;
74
75 // only the refresh window will be updated unless these variables are flagged 
76 int                     scr_copytop;
77 int                     scr_copyeverything;
78
79 float           scr_con_current;
80 float           scr_conlines;           // lines of console to display
81
82 float           oldscreensize, oldfov;
83 cvar_t          scr_viewsize = {"viewsize","100", true};
84 cvar_t          scr_fov = {"fov","90"}; // 10 - 170
85 cvar_t          scr_conspeed = {"scr_conspeed","300"};
86 cvar_t          scr_centertime = {"scr_centertime","2"};
87 cvar_t          scr_showram = {"showram","1"};
88 cvar_t          scr_showturtle = {"showturtle","0"};
89 cvar_t          scr_showpause = {"showpause","1"};
90 cvar_t          scr_printspeed = {"scr_printspeed","8"};
91 cvar_t          gl_triplebuffer = {"gl_triplebuffer", "1", true };
92 cvar_t          showfps = {"showfps", "0", true};
93
94 extern  cvar_t  crosshair;
95
96 qboolean        scr_initialized;                // ready to draw
97
98 qpic_t          *scr_ram;
99 qpic_t          *scr_net;
100 qpic_t          *scr_turtle;
101
102 int                     scr_fullupdate;
103
104 int                     clearconsole;
105 int                     clearnotify;
106
107 extern int                     sb_lines;
108
109 extern viddef_t        vid;                            // global video state
110
111 vrect_t         scr_vrect;
112
113 qboolean        scr_disabled_for_loading;
114 qboolean        scr_drawloading;
115 float           scr_disabled_time;
116
117 void SCR_ScreenShot_f (void);
118
119 /*
120 ===============================================================================
121
122 CENTER PRINTING
123
124 ===============================================================================
125 */
126
127 char            scr_centerstring[1024];
128 float           scr_centertime_start;   // for slow victory printing
129 float           scr_centertime_off;
130 int                     scr_center_lines;
131 int                     scr_erase_lines;
132 int                     scr_erase_center;
133
134 /*
135 ==============
136 SCR_CenterPrint
137
138 Called for important messages that should stay in the center of the screen
139 for a few moments
140 ==============
141 */
142 void SCR_CenterPrint (char *str)
143 {
144         strncpy (scr_centerstring, str, sizeof(scr_centerstring)-1);
145         scr_centertime_off = scr_centertime.value;
146         scr_centertime_start = cl.time;
147
148 // count the number of lines for centering
149         scr_center_lines = 1;
150         while (*str)
151         {
152                 if (*str == '\n')
153                         scr_center_lines++;
154                 str++;
155         }
156 }
157
158
159 void SCR_DrawCenterString (void)
160 {
161         char    *start;
162         int             l;
163         int             x, y;
164         int             remaining;
165
166 // the finale prints the characters one at a time
167         if (cl.intermission)
168                 remaining = scr_printspeed.value * (cl.time - scr_centertime_start);
169         else
170                 remaining = 9999;
171
172         scr_erase_center = 0;
173         start = scr_centerstring;
174
175         if (scr_center_lines <= 4)
176                 y = vid.height*0.35;
177         else
178                 y = 48;
179
180         do      
181         {
182         // scan the width of the line
183                 for (l=0 ; l<40 ; l++)
184                         if (start[l] == '\n' || !start[l])
185                                 break;
186                 x = (vid.width - l*8)/2;
187                 // LordHavoc: speedup
188                 if (l > 0)
189                 {
190                         if (remaining < l)
191                                 l = remaining;
192                         Draw_String(x, y, start, l);
193                         remaining -= l;
194                         if (remaining <= 0)
195                                 return;
196                 }
197                 /*
198                 for (j=0 ; j<l ; j++, x+=8)
199                 {
200                         Draw_Character (x, y, start[j]);        
201                         if (!remaining--)
202                                 return;
203                 }
204                 */
205                         
206                 y += 8;
207
208                 while (*start && *start != '\n')
209                         start++;
210
211                 if (!*start)
212                         break;
213                 start++;                // skip the \n
214         } while (1);
215 }
216
217 void SCR_CheckDrawCenterString (void)
218 {
219         scr_copytop = 1;
220         if (scr_center_lines > scr_erase_lines)
221                 scr_erase_lines = scr_center_lines;
222
223         scr_centertime_off -= host_frametime;
224         
225         if (scr_centertime_off <= 0 && !cl.intermission)
226                 return;
227         if (key_dest != key_game)
228                 return;
229
230         SCR_DrawCenterString ();
231 }
232
233 //=============================================================================
234
235 /*
236 ====================
237 CalcFov
238 ====================
239 */
240 float CalcFov (float fov_x, float width, float height)
241 {
242         float   a;
243         float   x;
244
245         if (fov_x < 1 || fov_x > 179)
246                 Sys_Error ("Bad fov: %f", fov_x);
247
248         x = width/tan(fov_x/360*M_PI);
249
250         a = atan (height/x);
251
252         a = a*360/M_PI;
253
254         return a;
255 }
256
257 /*
258 =================
259 SCR_CalcRefdef
260
261 Must be called whenever vid changes
262 Internal use only
263 =================
264 */
265 static void SCR_CalcRefdef (void)
266 {
267         float           size;
268         int             h;
269         qboolean                full = false;
270
271
272         scr_fullupdate = 0;             // force a background redraw
273         vid.recalc_refdef = 0;
274
275 // force the status bar to redraw
276 //      Sbar_Changed ();
277
278 //========================================
279         
280 // bound viewsize
281         if (scr_viewsize.value < 30)
282                 Cvar_Set ("viewsize","30");
283         if (scr_viewsize.value > 120)
284                 Cvar_Set ("viewsize","120");
285
286 // bound field of view
287         if (scr_fov.value < 10)
288                 Cvar_Set ("fov","10");
289         if (scr_fov.value > 170)
290                 Cvar_Set ("fov","170");
291
292 // intermission is always full screen   
293         if (cl.intermission)
294                 size = 120;
295         else
296                 size = scr_viewsize.value;
297
298         if (size >= 120)
299                 sb_lines = 0;           // no status bar at all
300         else if (size >= 110)
301                 sb_lines = 24;          // no inventory
302         else
303                 sb_lines = 24+16+8;
304
305         if (scr_viewsize.value >= 100.0)
306         {
307                 full = true;
308                 size = 100.0;
309         }
310         else
311                 size = scr_viewsize.value;
312         if (cl.intermission)
313         {
314                 full = true;
315                 size = 100;
316                 sb_lines = 0;
317         }
318         size /= 100.0;
319
320         // LordHavoc: always fullyscreen rendering
321         h = vid.height/* - sb_lines*/;
322
323         r_refdef.vrect.width = vid.width * size;
324         if (r_refdef.vrect.width < 96)
325         {
326                 size = 96.0 / r_refdef.vrect.width;
327                 r_refdef.vrect.width = 96;      // min for icons
328         }
329
330         r_refdef.vrect.height = vid.height * size;
331         //if (r_refdef.vrect.height > vid.height - sb_lines)
332         //      r_refdef.vrect.height = vid.height - sb_lines;
333         if (r_refdef.vrect.height > (int) vid.height)
334                         r_refdef.vrect.height = vid.height;
335         r_refdef.vrect.x = (vid.width - r_refdef.vrect.width)/2;
336         if (full)
337                 r_refdef.vrect.y = 0;
338         else 
339                 r_refdef.vrect.y = (h - r_refdef.vrect.height)/2;
340
341         r_refdef.fov_x = scr_fov.value;
342         r_refdef.fov_y = CalcFov (r_refdef.fov_x, r_refdef.vrect.width, r_refdef.vrect.height);
343
344         scr_vrect = r_refdef.vrect;
345 }
346
347
348 /*
349 =================
350 SCR_SizeUp_f
351
352 Keybinding command
353 =================
354 */
355 void SCR_SizeUp_f (void)
356 {
357         Cvar_SetValue ("viewsize",scr_viewsize.value+10);
358         vid.recalc_refdef = 1;
359 }
360
361
362 /*
363 =================
364 SCR_SizeDown_f
365
366 Keybinding command
367 =================
368 */
369 void SCR_SizeDown_f (void)
370 {
371         Cvar_SetValue ("viewsize",scr_viewsize.value-10);
372         vid.recalc_refdef = 1;
373 }
374
375 //============================================================================
376
377 /*
378 ==================
379 SCR_Init
380 ==================
381 */
382 void SCR_Init (void)
383 {
384
385         Cvar_RegisterVariable (&scr_fov);
386         Cvar_RegisterVariable (&scr_viewsize);
387         Cvar_RegisterVariable (&scr_conspeed);
388         Cvar_RegisterVariable (&scr_showram);
389         Cvar_RegisterVariable (&scr_showturtle);
390         Cvar_RegisterVariable (&scr_showpause);
391         Cvar_RegisterVariable (&scr_centertime);
392         Cvar_RegisterVariable (&scr_printspeed);
393         Cvar_RegisterVariable (&gl_triplebuffer);
394         Cvar_RegisterVariable (&showfps);
395
396 //
397 // register our commands
398 //
399         Cmd_AddCommand ("screenshot",SCR_ScreenShot_f);
400         Cmd_AddCommand ("sizeup",SCR_SizeUp_f);
401         Cmd_AddCommand ("sizedown",SCR_SizeDown_f);
402
403         scr_ram = Draw_PicFromWad ("ram");
404         scr_net = Draw_PicFromWad ("net");
405         scr_turtle = Draw_PicFromWad ("turtle");
406
407         scr_initialized = true;
408 }
409
410
411
412 /*
413 ==============
414 SCR_DrawRam
415 ==============
416 */
417 void SCR_DrawRam (void)
418 {
419         if (!scr_showram.value)
420                 return;
421
422         if (!r_cache_thrash)
423                 return;
424
425         Draw_Pic (scr_vrect.x+32, scr_vrect.y, scr_ram);
426 }
427
428 /*
429 ==============
430 SCR_DrawTurtle
431 ==============
432 */
433 void SCR_DrawTurtle (void)
434 {
435         static int      count;
436         
437         if (!scr_showturtle.value)
438                 return;
439
440         if (host_frametime < 0.1)
441         {
442                 count = 0;
443                 return;
444         }
445
446         count++;
447         if (count < 3)
448                 return;
449
450         Draw_Pic (scr_vrect.x, scr_vrect.y, scr_turtle);
451 }
452
453 /*
454 ==============
455 SCR_DrawNet
456 ==============
457 */
458 void SCR_DrawNet (void)
459 {
460         if (realtime - cl.last_received_message < 0.3)
461                 return;
462         if (cls.demoplayback)
463                 return;
464
465         Draw_Pic (scr_vrect.x+64, scr_vrect.y, scr_net);
466 }
467
468 /*
469 ==============
470 DrawPause
471 ==============
472 */
473 void SCR_DrawPause (void)
474 {
475         qpic_t  *pic;
476
477         if (!scr_showpause.value)               // turn off for screenshots
478                 return;
479
480         if (!cl.paused)
481                 return;
482
483         pic = Draw_CachePic ("gfx/pause.lmp");
484         Draw_Pic ( (vid.width - pic->width)/2, 
485                 (vid.height - 48 - pic->height)/2, pic);
486 }
487
488
489
490 /*
491 ==============
492 SCR_DrawLoading
493 ==============
494 */
495 void SCR_DrawLoading (void)
496 {
497         qpic_t  *pic;
498
499         if (!scr_drawloading)
500                 return;
501                 
502         pic = Draw_CachePic ("gfx/loading.lmp");
503         Draw_Pic ( (vid.width - pic->width)/2, 
504                 (vid.height - 48 - pic->height)/2, pic);
505 }
506
507
508
509 //=============================================================================
510
511
512 /*
513 ==================
514 SCR_SetUpToDrawConsole
515 ==================
516 */
517 void SCR_SetUpToDrawConsole (void)
518 {
519         Con_CheckResize ();
520         
521         //if (scr_drawloading)
522         //      return;         // never a console with loading plaque
523
524 // decide on the height of the console
525         con_forcedup = !cl.worldmodel || cls.signon != SIGNONS;
526
527         if (con_forcedup)
528         {
529                 scr_conlines = vid.height;              // full screen
530                 scr_con_current = scr_conlines;
531         }
532         else if (key_dest == key_console)
533                 scr_conlines = vid.height/2;    // half screen
534         else
535                 scr_conlines = 0;                               // none visible
536         
537         if (scr_conlines < scr_con_current)
538         {
539                 scr_con_current -= scr_conspeed.value*host_frametime;
540                 if (scr_conlines > scr_con_current)
541                         scr_con_current = scr_conlines;
542
543         }
544         else if (scr_conlines > scr_con_current)
545         {
546                 scr_con_current += scr_conspeed.value*host_frametime;
547                 if (scr_conlines < scr_con_current)
548                         scr_con_current = scr_conlines;
549         }
550
551         /*
552         if (clearconsole++ < vid.numpages)
553         {
554                 Sbar_Changed ();
555         }
556         else if (clearnotify++ < vid.numpages)
557         {
558         }
559         else
560                 con_notifylines = 0;
561         */
562 }
563         
564 /*
565 ==================
566 SCR_DrawConsole
567 ==================
568 */
569 void SCR_DrawConsole (void)
570 {
571         if (scr_con_current)
572         {
573                 scr_copyeverything = 1;
574                 Con_DrawConsole (scr_con_current, true);
575                 clearconsole = 0;
576         }
577         else
578         {
579                 if (key_dest == key_game || key_dest == key_message)
580                         Con_DrawNotify ();      // only draw notify in game
581         }
582 }
583
584
585 /* 
586 ============================================================================== 
587  
588                                                 SCREEN SHOTS 
589  
590 ============================================================================== 
591 */ 
592
593 typedef struct _TargaHeader {
594         unsigned char   id_length, colormap_type, image_type;
595         unsigned short  colormap_index, colormap_length;
596         unsigned char   colormap_size;
597         unsigned short  x_origin, y_origin, width, height;
598         unsigned char   pixel_size, attributes;
599 } TargaHeader;
600
601
602 /* 
603 ================== 
604 SCR_ScreenShot_f
605 ================== 
606 */  
607 void SCR_ScreenShot_f (void) 
608 {
609         byte            *buffer;
610         char            pcxname[80]; 
611         char            checkname[MAX_OSPATH];
612         int                     i, c, temp;
613 // 
614 // find a file name to save it to 
615 // 
616         strcpy(pcxname,"dp0000.tga");
617                 
618         for (i=0 ; i<=9999 ; i++) 
619         { 
620                 pcxname[2] = (i/1000)%10 + '0'; 
621                 pcxname[3] = (i/ 100)%10 + '0'; 
622                 pcxname[4] = (i/  10)%10 + '0'; 
623                 pcxname[5] = (i/   1)%10 + '0'; 
624                 sprintf (checkname, "%s/%s", com_gamedir, pcxname);
625                 if (Sys_FileTime(checkname) == -1)
626                         break;  // file doesn't exist
627         } 
628         if (i==10000)
629         {
630                 Con_Printf ("SCR_ScreenShot_f: Couldn't create a TGA file\n"); 
631                 return;
632         }
633
634
635         buffer = malloc(glwidth*glheight*3 + 18);
636         memset (buffer, 0, 18);
637         buffer[2] = 2;          // uncompressed type
638         buffer[12] = glwidth&255;
639         buffer[13] = glwidth>>8;
640         buffer[14] = glheight&255;
641         buffer[15] = glheight>>8;
642         buffer[16] = 24;        // pixel size
643
644         glReadPixels (glx, gly, glwidth, glheight, GL_RGB, GL_UNSIGNED_BYTE, buffer+18 ); 
645
646         // swap rgb to bgr
647         c = 18+glwidth*glheight*3;
648         for (i=18 ; i<c ; i+=3)
649         {
650                 temp = buffer[i];
651                 buffer[i] = buffer[i+2];
652                 buffer[i+2] = temp;
653         }
654         COM_WriteFile (pcxname, buffer, glwidth*glheight*3 + 18 );
655
656         free (buffer);
657         Con_Printf ("Wrote %s\n", pcxname);
658
659
660
661 //=============================================================================
662
663
664 /*
665 ===============
666 SCR_BeginLoadingPlaque
667
668 ================
669 */
670 void SCR_BeginLoadingPlaque (void)
671 {
672         S_StopAllSounds (true);
673
674         if (cls.state != ca_connected)
675                 return;
676         if (cls.signon != SIGNONS)
677                 return;
678         
679 // redraw with no console and the loading plaque
680         Con_ClearNotify ();
681         scr_centertime_off = 0;
682         scr_con_current = 0;
683
684         scr_drawloading = true;
685         scr_fullupdate = 0;
686 //      Sbar_Changed ();
687         SCR_UpdateScreen ();
688         scr_drawloading = false;
689
690         scr_disabled_for_loading = true;
691         scr_disabled_time = realtime;
692         scr_fullupdate = 0;
693 }
694
695 /*
696 ===============
697 SCR_EndLoadingPlaque
698
699 ================
700 */
701 void SCR_EndLoadingPlaque (void)
702 {
703         scr_disabled_for_loading = false;
704         scr_fullupdate = 0;
705         Con_ClearNotify ();
706 }
707
708 //=============================================================================
709
710 char    *scr_notifystring;
711 qboolean        scr_drawdialog;
712
713 void SCR_DrawNotifyString (void)
714 {
715         char    *start;
716         int             l;
717         int             x, y;
718
719         start = scr_notifystring;
720
721         y = vid.height*0.35;
722
723         do      
724         {
725         // scan the width of the line
726                 for (l=0 ; l<40 ; l++)
727                         if (start[l] == '\n' || !start[l])
728                                 break;
729                 x = (vid.width - l*8)/2;
730                 // LordHavoc: speedup
731 //              for (j=0 ; j<l ; j++, x+=8)
732 //                      Draw_Character (x, y, start[j]);        
733                 Draw_String (x, y, start, l);
734                         
735                 y += 8;
736
737                 while (*start && *start != '\n')
738                         start++;
739
740                 if (!*start)
741                         break;
742                 start++;                // skip the \n
743         } while (1);
744 }
745
746 /*
747 ==================
748 SCR_ModalMessage
749
750 Displays a text string in the center of the screen and waits for a Y or N
751 keypress.  
752 ==================
753 */
754 int SCR_ModalMessage (char *text)
755 {
756         if (cls.state == ca_dedicated)
757                 return true;
758
759         scr_notifystring = text;
760  
761 // draw a fresh screen
762         scr_fullupdate = 0;
763         scr_drawdialog = true;
764         SCR_UpdateScreen ();
765         scr_drawdialog = false;
766         
767         S_ClearBuffer ();               // so dma doesn't loop current sound
768
769         do
770         {
771                 key_count = -1;         // wait for a key down and up
772                 Sys_SendKeyEvents ();
773         } while (key_lastpress != 'y' && key_lastpress != 'n' && key_lastpress != K_ESCAPE);
774
775         scr_fullupdate = 0;
776         SCR_UpdateScreen ();
777
778         return key_lastpress == 'y';
779 }
780
781
782 //=============================================================================
783
784 /*
785 ===============
786 SCR_BringDownConsole
787
788 Brings the console down and fades the palettes back to normal
789 ================
790 */
791 void SCR_BringDownConsole (void)
792 {
793         int             i;
794         
795         scr_centertime_off = 0;
796         
797         for (i=0 ; i<20 && scr_conlines != scr_con_current ; i++)
798                 SCR_UpdateScreen ();
799
800         cl.cshifts[0].percent = 0;              // no area contents palette on next frame
801         VID_SetPalette (host_basepal);
802 }
803
804 void GL_Set2D (void);
805
806 extern void SHOWLMP_drawall();
807 extern cvar_t contrast;
808 extern cvar_t brightness;
809 extern cvar_t gl_lightmode;
810
811 void GL_BrightenScreen()
812 {
813         float f;
814         glDisable(GL_TEXTURE_2D);
815         glEnable(GL_BLEND);
816         f = brightness.value = bound(1.0f, brightness.value, 5.0f);
817         if (f > 1)
818         {
819                 glBlendFunc (GL_DST_COLOR, GL_ONE);
820                 glBegin (GL_TRIANGLES);
821                 while (f > 1)
822                 {
823                         if (f >= 2)
824                                 glColor3f (1, 1, 1);
825                         else
826                                 glColor3f (f-1, f-1, f-1);
827                         glVertex2f (-5000, -5000);
828                         glVertex2f (10000, -5000);
829                         glVertex2f (-5000, 10000);
830                         f *= 0.5;
831                 }
832                 glEnd ();
833         }
834         glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
835         contrast.value = bound(0.2, contrast.value, 1.0);
836         if (contrast.value < 1.0f)
837         {
838                 glBegin (GL_TRIANGLES);
839                 glColor4f (1, 1, 1, 1-contrast.value);
840                 glVertex2f (-5000, -5000);
841                 glVertex2f (10000, -5000);
842                 glVertex2f (-5000, 10000);
843                 glEnd ();
844         }
845
846         glEnable (GL_CULL_FACE);
847         glEnable (GL_DEPTH_TEST);
848         glDisable(GL_BLEND);
849         glEnable(GL_TEXTURE_2D);
850 }
851
852 /*
853 ==================
854 SCR_UpdateScreen
855
856 This is called every frame, and can also be called explicitly to flush
857 text to the screen.
858
859 WARNING: be very careful calling this from elsewhere, because the refresh
860 needs almost the entire 256k of stack space!
861 ==================
862 */
863 extern cvar_t gl_vertexarrays;
864 extern qboolean gl_arrays;
865 void GL_Finish();
866 int c_nodes;
867 void SCR_UpdateScreen (void)
868 {
869         static float    oldscr_viewsize;
870         double  time1, time2;
871
872         if (r_speeds.value)
873         {
874                 time1 = Sys_FloatTime ();
875                 c_brush_polys = 0;
876                 c_alias_polys = 0;
877                 c_nodes = 0;
878         }
879
880         if (!gl_arrays)
881                 gl_vertexarrays.value = 0;
882
883         vid.numpages = 2 + gl_triplebuffer.value;
884
885         scr_copytop = 0;
886         scr_copyeverything = 0;
887
888         if (scr_disabled_for_loading)
889         {
890                 if (realtime - scr_disabled_time > 60)
891                 {
892                         scr_disabled_for_loading = false;
893                         Con_Printf ("load failed.\n");
894                 }
895                 else
896                         return;
897         }
898
899         if (!scr_initialized || !con_initialized)
900                 return;                         // not initialized yet
901
902
903         GL_BeginRendering (&glx, &gly, &glwidth, &glheight);
904         
905         //
906         // determine size of refresh window
907         //
908         if (oldfov != scr_fov.value)
909         {
910                 oldfov = scr_fov.value;
911                 vid.recalc_refdef = true;
912         }
913
914         if (oldscreensize != scr_viewsize.value)
915         {
916                 oldscreensize = scr_viewsize.value;
917                 vid.recalc_refdef = true;
918         }
919
920         if (vid.recalc_refdef)
921                 SCR_CalcRefdef ();
922
923         glClearColor(0,0,0,0);
924         glClear (GL_COLOR_BUFFER_BIT); // LordHavoc: clear the screen (around the view as well)
925
926 //
927 // do 3D refresh drawing, and then update the screen
928 //
929         SCR_SetUpToDrawConsole ();
930
931         V_RenderView ();
932
933         GL_Set2D ();
934
935         if (scr_drawdialog)
936         {
937                 Sbar_Draw ();
938 //              Draw_FadeScreen ();
939                 SCR_DrawNotifyString ();
940                 scr_copyeverything = true;
941         }
942         else if (scr_drawloading)
943         {
944                 SCR_DrawLoading ();
945                 Sbar_Draw ();
946         }
947         else if (cl.intermission == 1 && key_dest == key_game)
948         {
949                 Sbar_IntermissionOverlay ();
950         }
951         else if (cl.intermission == 2 && key_dest == key_game)
952         {
953                 Sbar_FinaleOverlay ();
954                 SCR_CheckDrawCenterString ();
955         }
956         else
957         {
958                 if (crosshair.value)
959                         Draw_Character (scr_vrect.x + scr_vrect.width/2, scr_vrect.y + scr_vrect.height/2, '+');
960                 
961                 SCR_DrawRam ();
962                 SCR_DrawNet ();
963                 SCR_DrawTurtle ();
964                 SCR_DrawPause ();
965                 SCR_CheckDrawCenterString ();
966                 Sbar_Draw ();
967                 SHOWLMP_drawall();
968                 SCR_DrawConsole ();     
969                 M_Draw ();
970         }
971
972         if (showfps.value)
973         {
974                 static double currtime;
975                 double newtime;
976                 char temp[32];
977                 int calc;
978                 newtime = Sys_FloatTime();
979                 calc = (int) (100.0 / (newtime - currtime));
980                 sprintf(temp, "% 4i.%02i fps", calc / 100, calc % 100);
981                 currtime = newtime;
982                 Draw_String(vid.width - (12*8), 0, temp, 9999);
983         }
984
985         V_UpdatePalette ();
986
987         GL_BrightenScreen();
988
989         GL_Finish();
990
991         if (r_speeds.value)
992         {
993                 time2 = Sys_FloatTime ();
994                 Con_Printf ("%3i ms  %4i wpoly %4i epoly %4i transpoly %4i BSPnodes\n", (int)((time2-time1)*1000), c_brush_polys, c_alias_polys, currenttranspoly, c_nodes); 
995         }
996         GL_EndRendering ();
997 }
998
999 // for profiling, this is seperated
1000 void GL_Finish()
1001 {
1002         glFinish ();
1003 }
1004