61aafc21f096f3d5941cf6c2881533aca897c504
[xonotic/darkplaces.git] / gl_rmain.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 // r_main.c
21
22 #include "quakedef.h"
23 #include "r_shadow.h"
24
25 // used for dlight push checking and other things
26 int r_framecount;
27
28 // used for visibility checking
29 qbyte r_pvsbits[(MAX_MAP_LEAFS+7)>>3];
30
31 mplane_t frustum[4];
32
33 matrix4x4_t r_identitymatrix;
34
35 int c_alias_polys, c_light_polys, c_faces, c_nodes, c_leafs, c_models, c_bmodels, c_sprites, c_particles, c_dlights;
36
37 // true during envmap command capture
38 qboolean envmap;
39
40 float r_farclip;
41
42 // view origin
43 vec3_t r_vieworigin;
44 vec3_t r_viewforward;
45 vec3_t r_viewleft;
46 vec3_t r_viewright;
47 vec3_t r_viewup;
48 int r_view_x;
49 int r_view_y;
50 int r_view_width;
51 int r_view_height;
52 float r_view_fov_x;
53 float r_view_fov_y;
54 matrix4x4_t r_view_matrix;
55
56 //
57 // screen size info
58 //
59 refdef_t r_refdef;
60
61 // 8.8 fraction of base light value
62 unsigned short d_lightstylevalue[256];
63
64 cvar_t r_drawentities = {0, "r_drawentities","1"};
65 cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1"};
66 cvar_t r_speeds = {0, "r_speeds","0"};
67 cvar_t r_fullbright = {0, "r_fullbright","0"};
68 cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1"};
69 cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1"};
70 cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1"};
71 cvar_t r_drawcollisionbrushes = {0, "r_drawcollisionbrushes", "0"};
72
73 cvar_t gl_fogenable = {0, "gl_fogenable", "0"};
74 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25"};
75 cvar_t gl_fogred = {0, "gl_fogred","0.3"};
76 cvar_t gl_foggreen = {0, "gl_foggreen","0.3"};
77 cvar_t gl_fogblue = {0, "gl_fogblue","0.3"};
78 cvar_t gl_fogstart = {0, "gl_fogstart", "0"};
79 cvar_t gl_fogend = {0, "gl_fogend","0"};
80
81 cvar_t r_textureunits = {0, "r_textureunits", "32"};
82
83 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "1"};
84 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1"};
85 cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1"};
86 cvar_t r_watershader = {CVAR_SAVE, "r_watershader", "1"};
87
88
89 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
90 {
91         int i;
92         for (i = 0;i < verts;i++)
93         {
94                 out[0] = in[0] * r;
95                 out[1] = in[1] * g;
96                 out[2] = in[2] * b;
97                 out[3] = in[3];
98                 in += 4;
99                 out += 4;
100         }
101 }
102
103 void R_FillColors(float *out, int verts, float r, float g, float b, float a)
104 {
105         int i;
106         for (i = 0;i < verts;i++)
107         {
108                 out[0] = r;
109                 out[1] = g;
110                 out[2] = b;
111                 out[3] = a;
112                 out += 4;
113         }
114 }
115
116 /*
117 ====================
118 R_TimeRefresh_f
119
120 For program optimization
121 ====================
122 */
123 qboolean intimerefresh = 0;
124 static void R_TimeRefresh_f (void)
125 {
126         int i;
127         float timestart, timedelta, oldangles[3];
128
129         intimerefresh = 1;
130         VectorCopy(cl.viewangles, oldangles);
131         VectorClear(cl.viewangles);
132
133         timestart = Sys_DoubleTime();
134         for (i = 0;i < 128;i++)
135         {
136                 Matrix4x4_CreateFromQuakeEntity(&r_refdef.viewentitymatrix, r_vieworigin[0], r_vieworigin[1], r_vieworigin[2], 0, i / 128.0 * 360.0, 0, 1);
137                 CL_UpdateScreen();
138         }
139         timedelta = Sys_DoubleTime() - timestart;
140
141         VectorCopy(oldangles, cl.viewangles);
142         intimerefresh = 0;
143         Con_Printf ("%f seconds (%f fps)\n", timedelta, 128/timedelta);
144 }
145
146 vec3_t fogcolor;
147 vec_t fogdensity;
148 float fog_density, fog_red, fog_green, fog_blue;
149 qboolean fogenabled;
150 qboolean oldgl_fogenable;
151 void R_UpdateFog(void)
152 {
153         if (gamemode == GAME_NEHAHRA)
154         {
155                 if (gl_fogenable.integer)
156                 {
157                         oldgl_fogenable = true;
158                         fog_density = gl_fogdensity.value;
159                         fog_red = gl_fogred.value;
160                         fog_green = gl_foggreen.value;
161                         fog_blue = gl_fogblue.value;
162                 }
163                 else if (oldgl_fogenable)
164                 {
165                         oldgl_fogenable = false;
166                         fog_density = 0;
167                         fog_red = 0;
168                         fog_green = 0;
169                         fog_blue = 0;
170                 }
171         }
172         if (fog_density)
173         {
174                 fogcolor[0] = fog_red   = bound(0.0f, fog_red  , 1.0f);
175                 fogcolor[1] = fog_green = bound(0.0f, fog_green, 1.0f);
176                 fogcolor[2] = fog_blue  = bound(0.0f, fog_blue , 1.0f);
177         }
178         if (fog_density)
179         {
180                 fogenabled = true;
181                 fogdensity = -4000.0f / (fog_density * fog_density);
182                 // fog color was already set
183         }
184         else
185                 fogenabled = false;
186 }
187
188 // FIXME: move this to client?
189 void FOG_clear(void)
190 {
191         if (gamemode == GAME_NEHAHRA)
192         {
193                 Cvar_Set("gl_fogenable", "0");
194                 Cvar_Set("gl_fogdensity", "0.2");
195                 Cvar_Set("gl_fogred", "0.3");
196                 Cvar_Set("gl_foggreen", "0.3");
197                 Cvar_Set("gl_fogblue", "0.3");
198         }
199         fog_density = fog_red = fog_green = fog_blue = 0.0f;
200 }
201
202 // FIXME: move this to client?
203 void FOG_registercvars(void)
204 {
205         if (gamemode == GAME_NEHAHRA)
206         {
207                 Cvar_RegisterVariable (&gl_fogenable);
208                 Cvar_RegisterVariable (&gl_fogdensity);
209                 Cvar_RegisterVariable (&gl_fogred);
210                 Cvar_RegisterVariable (&gl_foggreen);
211                 Cvar_RegisterVariable (&gl_fogblue);
212                 Cvar_RegisterVariable (&gl_fogstart);
213                 Cvar_RegisterVariable (&gl_fogend);
214         }
215 }
216
217 void gl_main_start(void)
218 {
219 }
220
221 void gl_main_shutdown(void)
222 {
223 }
224
225 extern void CL_ParseEntityLump(char *entitystring);
226 void gl_main_newmap(void)
227 {
228         int l;
229         char *entities, entname[MAX_QPATH];
230         r_framecount = 1;
231         if (cl.worldmodel)
232         {
233                 strcpy(entname, cl.worldmodel->name);
234                 l = strlen(entname) - 4;
235                 if (l >= 0 && !strcmp(entname + l, ".bsp"))
236                 {
237                         strcpy(entname + l, ".ent");
238                         if ((entities = FS_LoadFile(entname, true)))
239                         {
240                                 CL_ParseEntityLump(entities);
241                                 Mem_Free(entities);
242                                 return;
243                         }
244                 }
245                 if (cl.worldmodel->brush.entities)
246                         CL_ParseEntityLump(cl.worldmodel->brush.entities);
247         }
248 }
249
250 void GL_Main_Init(void)
251 {
252         Matrix4x4_CreateIdentity(&r_identitymatrix);
253 // FIXME: move this to client?
254         FOG_registercvars();
255         Cmd_AddCommand("timerefresh", R_TimeRefresh_f);
256         Cvar_RegisterVariable(&r_drawentities);
257         Cvar_RegisterVariable(&r_drawviewmodel);
258         Cvar_RegisterVariable(&r_speeds);
259         Cvar_RegisterVariable(&r_fullbrights);
260         Cvar_RegisterVariable(&r_wateralpha);
261         Cvar_RegisterVariable(&r_dynamic);
262         Cvar_RegisterVariable(&r_fullbright);
263         Cvar_RegisterVariable(&r_textureunits);
264         Cvar_RegisterVariable(&r_lerpsprites);
265         Cvar_RegisterVariable(&r_lerpmodels);
266         Cvar_RegisterVariable(&r_waterscroll);
267         Cvar_RegisterVariable(&r_watershader);
268         Cvar_RegisterVariable(&r_drawcollisionbrushes);
269         if (gamemode == GAME_NEHAHRA || gamemode == GAME_NEXUIZ || gamemode == GAME_TENEBRAE)
270                 Cvar_SetValue("r_fullbrights", 0);
271         R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap);
272 }
273
274 static vec3_t r_farclip_origin;
275 static vec3_t r_farclip_direction;
276 static vec_t r_farclip_directiondist;
277 static vec_t r_farclip_meshfarclip;
278 static int r_farclip_directionbit0;
279 static int r_farclip_directionbit1;
280 static int r_farclip_directionbit2;
281
282 // enlarge farclip to accomodate box
283 static void R_FarClip_Box(vec3_t mins, vec3_t maxs)
284 {
285         float d;
286         d = (r_farclip_directionbit0 ? mins[0] : maxs[0]) * r_farclip_direction[0]
287           + (r_farclip_directionbit1 ? mins[1] : maxs[1]) * r_farclip_direction[1]
288           + (r_farclip_directionbit2 ? mins[2] : maxs[2]) * r_farclip_direction[2];
289         if (r_farclip_meshfarclip < d)
290                 r_farclip_meshfarclip = d;
291 }
292
293 // return farclip value
294 static float R_FarClip(vec3_t origin, vec3_t direction, vec_t startfarclip)
295 {
296         int i;
297
298         VectorCopy(origin, r_farclip_origin);
299         VectorCopy(direction, r_farclip_direction);
300         r_farclip_directiondist = DotProduct(r_farclip_origin, r_farclip_direction);
301         r_farclip_directionbit0 = r_farclip_direction[0] < 0;
302         r_farclip_directionbit1 = r_farclip_direction[1] < 0;
303         r_farclip_directionbit2 = r_farclip_direction[2] < 0;
304         r_farclip_meshfarclip = r_farclip_directiondist + startfarclip;
305
306         if (cl.worldmodel)
307                 R_FarClip_Box(cl.worldmodel->normalmins, cl.worldmodel->normalmaxs);
308         for (i = 0;i < r_refdef.numentities;i++)
309                 R_FarClip_Box(r_refdef.entities[i]->mins, r_refdef.entities[i]->maxs);
310         
311         return r_farclip_meshfarclip - r_farclip_directiondist;
312 }
313
314 extern void R_Textures_Init(void);
315 extern void Mod_RenderInit(void);
316 extern void GL_Draw_Init(void);
317 extern void GL_Main_Init(void);
318 extern void R_Shadow_Init(void);
319 extern void GL_Models_Init(void);
320 extern void R_Sky_Init(void);
321 extern void GL_Surf_Init(void);
322 extern void R_Crosshairs_Init(void);
323 extern void R_Light_Init(void);
324 extern void R_Particles_Init(void);
325 extern void R_Explosion_Init(void);
326 extern void ui_init(void);
327 extern void gl_backend_init(void);
328 extern void Sbar_Init(void);
329 extern void R_LightningBeams_Init(void);
330
331 void Render_Init(void)
332 {
333         R_Textures_Init();
334         Mod_RenderInit();
335         gl_backend_init();
336         R_MeshQueue_Init();
337         GL_Draw_Init();
338         GL_Main_Init();
339         R_Shadow_Init();
340         GL_Models_Init();
341         R_Sky_Init();
342         GL_Surf_Init();
343         R_Crosshairs_Init();
344         R_Light_Init();
345         R_Particles_Init();
346         R_Explosion_Init();
347         //ui_init();
348         UI_Init();
349         Sbar_Init();
350         R_LightningBeams_Init();
351 }
352
353 /*
354 ===============
355 GL_Init
356 ===============
357 */
358 extern char *ENGINE_EXTENSIONS;
359 void GL_Init (void)
360 {
361         VID_CheckExtensions();
362
363         // LordHavoc: report supported extensions
364         Con_DPrintf("\nengine extensions: %s\n", ENGINE_EXTENSIONS);
365 }
366
367 int R_CullBox(const vec3_t mins, const vec3_t maxs)
368 {
369         int i;
370         mplane_t *p;
371         for (i = 0;i < 4;i++)
372         {
373                 p = frustum + i;
374                 switch(p->signbits)
375                 {
376                 default:
377                 case 0:
378                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
379                                 return true;
380                         break;
381                 case 1:
382                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
383                                 return true;
384                         break;
385                 case 2:
386                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
387                                 return true;
388                         break;
389                 case 3:
390                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
391                                 return true;
392                         break;
393                 case 4:
394                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
395                                 return true;
396                         break;
397                 case 5:
398                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
399                                 return true;
400                         break;
401                 case 6:
402                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
403                                 return true;
404                         break;
405                 case 7:
406                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
407                                 return true;
408                         break;
409                 }
410         }
411         return false;
412 }
413
414 //==================================================================================
415
416 static void R_MarkEntities (void)
417 {
418         int i;
419         entity_render_t *ent;
420
421         ent = &cl_entities[0].render;
422         Matrix4x4_CreateIdentity(&ent->matrix);
423         Matrix4x4_CreateIdentity(&ent->inversematrix);
424
425         if (!r_drawentities.integer)
426                 return;
427
428         for (i = 0;i < r_refdef.numentities;i++)
429         {
430                 ent = r_refdef.entities[i];
431                 Mod_CheckLoaded(ent->model);
432                 // some of the renderer still relies on origin...
433                 Matrix4x4_OriginFromMatrix(&ent->matrix, ent->origin);
434                 // some of the renderer still relies on scale...
435                 ent->scale = Matrix4x4_ScaleFromMatrix(&ent->matrix);
436                 R_LerpAnimation(ent);
437                 R_UpdateEntLights(ent);
438                 if ((chase_active.integer || !(ent->flags & RENDER_EXTERIORMODEL))
439                  && !VIS_CullBox(ent->mins, ent->maxs)
440                  && (!envmap || !(ent->flags & (RENDER_VIEWMODEL | RENDER_EXTERIORMODEL))))
441                         ent->visframe = r_framecount;
442         }
443 }
444
445 // only used if skyrendermasked, and normally returns false
446 int R_DrawBrushModelsSky (void)
447 {
448         int i, sky;
449         entity_render_t *ent;
450
451         if (!r_drawentities.integer)
452                 return false;
453
454         sky = false;
455         for (i = 0;i < r_refdef.numentities;i++)
456         {
457                 ent = r_refdef.entities[i];
458                 if (ent->visframe == r_framecount && ent->model && ent->model->DrawSky)
459                 {
460                         ent->model->DrawSky(ent);
461                         sky = true;
462                 }
463         }
464         return sky;
465 }
466
467 /*
468 =============
469 R_DrawViewModel
470 =============
471 */
472 /*
473 void R_DrawViewModel (void)
474 {
475         entity_render_t *ent;
476
477         // FIXME: move these checks to client
478         if (!r_drawviewmodel.integer || chase_active.integer || envmap || !r_drawentities.integer || cl.items & IT_INVISIBILITY || cl.stats[STAT_HEALTH] <= 0 || !cl.viewent.render.model)
479                 return;
480
481         ent = &cl.viewent.render;
482         Mod_CheckLoaded(ent->model);
483         R_LerpAnimation(ent);
484         Matrix4x4_CreateFromQuakeEntity(&ent->matrix, ent->origin[0], ent->origin[1], ent->origin[2], -ent->angles[0], ent->angles[1], ent->angles[2], ent->scale);
485         Matrix4x4_Invert_Simple(&ent->inversematrix, &ent->matrix);
486         R_UpdateEntLights(ent);
487         ent->model->Draw(ent);
488 }
489 */
490
491 void R_DrawNoModel(entity_render_t *ent);
492 void R_DrawModels(void)
493 {
494         int i;
495         entity_render_t *ent;
496
497         if (!r_drawentities.integer)
498                 return;
499
500         for (i = 0;i < r_refdef.numentities;i++)
501         {
502                 ent = r_refdef.entities[i];
503                 if (ent->visframe == r_framecount)
504                 {
505                         if (ent->model && ent->model->Draw != NULL)
506                                 ent->model->Draw(ent);
507                         else
508                                 R_DrawNoModel(ent);
509                 }
510         }
511 }
512
513 static void R_SetFrustum(void)
514 {
515         // break apart the view matrix into vectors for various purposes
516         Matrix4x4_ToVectors(&r_view_matrix, r_viewforward, r_viewleft, r_viewup, r_vieworigin);
517         VectorNegate(r_viewleft, r_viewright);
518
519         // LordHavoc: note to all quake engine coders, the special case for 90
520         // degrees assumed a square view (wrong), so I removed it, Quake2 has it
521         // disabled as well.
522
523         // rotate R_VIEWFORWARD right by FOV_X/2 degrees
524         RotatePointAroundVector( frustum[0].normal, r_viewup, r_viewforward, -(90 - r_view_fov_x / 2));
525         frustum[0].dist = DotProduct (r_vieworigin, frustum[0].normal);
526         PlaneClassify(&frustum[0]);
527
528         // rotate R_VIEWFORWARD left by FOV_X/2 degrees
529         RotatePointAroundVector( frustum[1].normal, r_viewup, r_viewforward, (90 - r_view_fov_x / 2));
530         frustum[1].dist = DotProduct (r_vieworigin, frustum[1].normal);
531         PlaneClassify(&frustum[1]);
532
533         // rotate R_VIEWFORWARD up by FOV_X/2 degrees
534         RotatePointAroundVector( frustum[2].normal, r_viewleft, r_viewforward, -(90 - r_view_fov_y / 2));
535         frustum[2].dist = DotProduct (r_vieworigin, frustum[2].normal);
536         PlaneClassify(&frustum[2]);
537
538         // rotate R_VIEWFORWARD down by FOV_X/2 degrees
539         RotatePointAroundVector( frustum[3].normal, r_viewleft, r_viewforward, (90 - r_view_fov_y / 2));
540         frustum[3].dist = DotProduct (r_vieworigin, frustum[3].normal);
541         PlaneClassify(&frustum[3]);
542 }
543
544 static void R_BlendView(void)
545 {
546         rmeshstate_t m;
547         float r;
548         float vertex3f[3*3];
549
550         if (r_refdef.viewblend[3] < 0.01f)
551                 return;
552
553         R_Mesh_Matrix(&r_identitymatrix);
554
555         memset(&m, 0, sizeof(m));
556         R_Mesh_State_Texture(&m);
557
558         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
559         GL_DepthMask(true);
560         GL_DepthTest(false); // magic
561         GL_VertexPointer(vertex3f);
562         GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
563         r = 64;
564         vertex3f[0] = r_vieworigin[0] + r_viewforward[0] * 1.5 + r_viewleft[0] * r - r_viewup[0] * r;
565         vertex3f[1] = r_vieworigin[1] + r_viewforward[1] * 1.5 + r_viewleft[1] * r - r_viewup[1] * r;
566         vertex3f[2] = r_vieworigin[2] + r_viewforward[2] * 1.5 + r_viewleft[2] * r - r_viewup[2] * r;
567         vertex3f[3] = r_vieworigin[0] + r_viewforward[0] * 1.5 + r_viewleft[0] * r + r_viewup[0] * r * 3;
568         vertex3f[4] = r_vieworigin[1] + r_viewforward[1] * 1.5 + r_viewleft[1] * r + r_viewup[1] * r * 3;
569         vertex3f[5] = r_vieworigin[2] + r_viewforward[2] * 1.5 + r_viewleft[2] * r + r_viewup[2] * r * 3;
570         vertex3f[6] = r_vieworigin[0] + r_viewforward[0] * 1.5 - r_viewleft[0] * r * 3 - r_viewup[0] * r;
571         vertex3f[7] = r_vieworigin[1] + r_viewforward[1] * 1.5 - r_viewleft[1] * r * 3 - r_viewup[1] * r;
572         vertex3f[8] = r_vieworigin[2] + r_viewforward[2] * 1.5 - r_viewleft[2] * r * 3 - r_viewup[2] * r;
573         R_Mesh_Draw(3, 1, polygonelements);
574 }
575
576 void R_UpdateWorld(void)
577 {
578         if (!r_refdef.entities/* || !cl.worldmodel*/)
579                 return; //Host_Error ("R_RenderView: NULL worldmodel");
580
581         if (r_shadow_realtime_world.integer && !gl_stencil)
582         {
583                 Con_Printf("Realtime world lighting requires 32bit color; turning off r_shadow_realtime_world, please type vid_bitsperpixel 32;vid_restart and try again\n");
584                 Cvar_SetValueQuick(&r_shadow_realtime_world, 0);
585         }
586
587         // don't allow cheats in multiplayer
588         if (!cl.islocalgame)
589         {
590                 if (r_fullbright.integer != 0)
591                         Cvar_Set ("r_fullbright", "0");
592                 if (r_ambient.value != 0)
593                         Cvar_Set ("r_ambient", "0");
594         }
595
596         R_Textures_Frame();
597         R_UpdateFog();
598         R_UpdateLights();
599 }
600
601 void R_RenderScene(void);
602
603 /*
604 ================
605 R_RenderView
606 ================
607 */
608 void R_RenderView(void)
609 {
610         if (!r_refdef.entities/* || !cl.worldmodel*/)
611                 return; //Host_Error ("R_RenderView: NULL worldmodel");
612         
613         r_view_width = bound(0, r_refdef.width, vid.realwidth);
614         r_view_height = bound(0, r_refdef.height, vid.realheight);
615         r_view_x = bound(0, r_refdef.x, vid.realwidth - r_refdef.width);
616         r_view_y = bound(0, r_refdef.y, vid.realheight - r_refdef.height);
617         r_view_fov_x = bound(1, r_refdef.fov_x, 170);
618         r_view_fov_y = bound(1, r_refdef.fov_y, 170);
619         r_view_matrix = r_refdef.viewentitymatrix;
620
621         // GL is weird because it's bottom to top, r_view_y is top to bottom
622         qglViewport(r_view_x, vid.realheight - (r_view_y + r_view_height), r_view_width, r_view_height);
623         GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height);
624         GL_ScissorTest(true);
625         R_ClearScreen();
626
627         R_Mesh_Start();
628         R_TimeReport("setup");
629
630         qglDepthFunc(GL_LEQUAL);
631         qglPolygonOffset(0, 0);
632         qglEnable(GL_POLYGON_OFFSET_FILL);
633
634         R_RenderScene();
635
636         qglPolygonOffset(0, 0);
637         qglDisable(GL_POLYGON_OFFSET_FILL);
638
639         R_BlendView();
640         R_TimeReport("blendview");
641         
642         R_Mesh_Finish();
643         R_TimeReport("meshfinish");
644
645         GL_Scissor(0, 0, vid.realwidth, vid.realheight);
646         GL_ScissorTest(false);
647 }
648
649 extern void R_DrawLightningBeams (void);
650 void R_RenderScene(void)
651 {
652         entity_render_t *world;
653
654         // don't let sound skip if going slow
655         if (!intimerefresh && !r_speeds.integer)
656                 S_ExtraUpdate ();
657
658         r_framecount++;
659
660         R_SetFrustum();
661
662         r_farclip = R_FarClip(r_vieworigin, r_viewforward, 768.0f) + 256.0f;
663         if (gl_stencil && ((r_shadow_realtime_world.integer && r_shadow_worldshadows.integer) || ((r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && r_shadow_dlightshadows.integer)))
664                 GL_SetupView_Mode_PerspectiveInfiniteFarClip(r_view_fov_x, r_view_fov_y, 1.0f);
665         else
666                 GL_SetupView_Mode_Perspective(r_view_fov_x, r_view_fov_y, 1.0f, r_farclip);
667
668         GL_SetupView_Orientation_FromEntity(&r_view_matrix);
669
670         R_SkyStartFrame();
671
672         if (cl.worldmodel && cl.worldmodel->brush.FatPVS)
673                 cl.worldmodel->brush.FatPVS(cl.worldmodel, r_vieworigin, 2, r_pvsbits, sizeof(r_pvsbits));
674         world = &cl_entities[0].render;
675         R_WorldVisibility(world);
676         R_TimeReport("worldvis");
677
678         R_MarkEntities();
679         R_TimeReport("markentity");
680
681         R_MeshQueue_BeginScene();
682
683         R_Shadow_UpdateWorldLightSelection();
684
685         // don't let sound skip if going slow
686         if (!intimerefresh && !r_speeds.integer)
687                 S_ExtraUpdate ();
688
689         if (R_DrawBrushModelsSky())
690                 R_TimeReport("bmodelsky");
691
692         // must occur early because it can draw sky
693         R_DrawWorld(world);
694         R_TimeReport("world");
695
696         // don't let sound skip if going slow
697         if (!intimerefresh && !r_speeds.integer)
698                 S_ExtraUpdate ();
699
700         R_DrawModels();
701         R_TimeReport("models");
702
703         // don't let sound skip if going slow
704         if (!intimerefresh && !r_speeds.integer)
705                 S_ExtraUpdate ();
706
707         R_ShadowVolumeLighting(false);
708         R_TimeReport("rtlights");
709
710         // don't let sound skip if going slow
711         if (!intimerefresh && !r_speeds.integer)
712                 S_ExtraUpdate ();
713
714         R_DrawLightningBeams();
715         R_TimeReport("lightning");
716
717         R_DrawParticles();
718         R_TimeReport("particles");
719
720         R_DrawExplosions();
721         R_TimeReport("explosions");
722
723         R_MeshQueue_RenderTransparent();
724         R_TimeReport("drawtrans");
725
726         R_DrawCoronas();
727         R_TimeReport("coronas");
728
729         R_DrawWorldCrosshair();
730         R_TimeReport("crosshair");
731
732         R_MeshQueue_Render();
733         R_MeshQueue_EndScene();
734
735         if (r_shadow_visiblevolumes.integer)
736         {
737                 R_ShadowVolumeLighting(true);
738                 R_TimeReport("shadowvolume");
739         }
740
741         // don't let sound skip if going slow
742         if (!intimerefresh && !r_speeds.integer)
743                 S_ExtraUpdate ();
744 }
745
746 /*
747 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
748 {
749         int i;
750         float *v, *c, f1, f2, diff[3], vertex3f[8*3], color4f[8*4];
751         rmeshstate_t m;
752         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
753         GL_DepthMask(false);
754         GL_DepthTest(true);
755         R_Mesh_Matrix(&r_identitymatrix);
756
757         memset(&m, 0, sizeof(m));
758         R_Mesh_State_Texture(&m);
759
760         R_Mesh_GetSpace(8);
761         vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2];
762         vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
763         vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
764         vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
765         vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
766         vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
767         vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
768         vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
769         GL_ColorPointer(color);
770         R_FillColors(color, 8, cr, cg, cb, ca);
771         if (fogenabled)
772         {
773                 for (i = 0, v = vertex, c = color;i < 8;i++, v += 4, c += 4)
774                 {
775                         VectorSubtract(v, r_vieworigin, diff);
776                         f2 = exp(fogdensity/DotProduct(diff, diff));
777                         f1 = 1 - f2;
778                         c[0] = c[0] * f1 + fogcolor[0] * f2;
779                         c[1] = c[1] * f1 + fogcolor[1] * f2;
780                         c[2] = c[2] * f1 + fogcolor[2] * f2;
781                 }
782         }
783         R_Mesh_Draw(8, 12);
784 }
785 */
786
787 int nomodelelements[24] =
788 {
789         5, 2, 0,
790         5, 1, 2,
791         5, 0, 3,
792         5, 3, 1,
793         0, 2, 4,
794         2, 1, 4,
795         3, 0, 4,
796         1, 3, 4
797 };
798
799 float nomodelvertex3f[6*3] =
800 {
801         -16,   0,   0,
802          16,   0,   0,
803           0, -16,   0,
804           0,  16,   0,
805           0,   0, -16,
806           0,   0,  16
807 };
808
809 float nomodelcolor4f[6*4] =
810 {
811         0.0f, 0.0f, 0.5f, 1.0f,
812         0.0f, 0.0f, 0.5f, 1.0f,
813         0.0f, 0.5f, 0.0f, 1.0f,
814         0.0f, 0.5f, 0.0f, 1.0f,
815         0.5f, 0.0f, 0.0f, 1.0f,
816         0.5f, 0.0f, 0.0f, 1.0f
817 };
818
819 void R_DrawNoModelCallback(const void *calldata1, int calldata2)
820 {
821         const entity_render_t *ent = calldata1;
822         int i;
823         float f1, f2, *c, diff[3];
824         float color4f[6*4];
825         rmeshstate_t m;
826         R_Mesh_Matrix(&ent->matrix);
827
828         memset(&m, 0, sizeof(m));
829         R_Mesh_State_Texture(&m);
830
831         if (ent->flags & EF_ADDITIVE)
832         {
833                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
834                 GL_DepthMask(false);
835         }
836         else if (ent->alpha < 1)
837         {
838                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
839                 GL_DepthMask(false);
840         }
841         else
842         {
843                 GL_BlendFunc(GL_ONE, GL_ZERO);
844                 GL_DepthMask(true);
845         }
846         GL_DepthTest(true);
847         GL_VertexPointer(nomodelvertex3f);
848         if (fogenabled)
849         {
850                 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
851                 GL_ColorPointer(color4f);
852                 VectorSubtract(ent->origin, r_vieworigin, diff);
853                 f2 = exp(fogdensity/DotProduct(diff, diff));
854                 f1 = 1 - f2;
855                 for (i = 0, c = color4f;i < 6;i++, c += 4)
856                 {
857                         c[0] = (c[0] * f1 + fogcolor[0] * f2);
858                         c[1] = (c[1] * f1 + fogcolor[1] * f2);
859                         c[2] = (c[2] * f1 + fogcolor[2] * f2);
860                         c[3] *= ent->alpha;
861                 }
862         }
863         else if (ent->alpha != 1)
864         {
865                 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
866                 GL_ColorPointer(color4f);
867                 for (i = 0, c = color4f;i < 6;i++, c += 4)
868                         c[3] *= ent->alpha;
869         }
870         else
871                 GL_ColorPointer(nomodelcolor4f);
872         R_Mesh_Draw(6, 8, nomodelelements);
873 }
874
875 void R_DrawNoModel(entity_render_t *ent)
876 {
877         //if ((ent->effects & EF_ADDITIVE) || (ent->alpha < 1))
878                 R_MeshQueue_AddTransparent(ent->origin, R_DrawNoModelCallback, ent, 0);
879         //else
880         //      R_DrawNoModelCallback(ent, 0);
881 }
882
883 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
884 {
885         vec3_t right1, right2, diff, normal;
886
887         VectorSubtract (org2, org1, normal);
888         VectorNormalizeFast (normal);
889
890         // calculate 'right' vector for start
891         VectorSubtract (r_vieworigin, org1, diff);
892         VectorNormalizeFast (diff);
893         CrossProduct (normal, diff, right1);
894
895         // calculate 'right' vector for end
896         VectorSubtract (r_vieworigin, org2, diff);
897         VectorNormalizeFast (diff);
898         CrossProduct (normal, diff, right2);
899
900         vert[ 0] = org1[0] + width * right1[0];
901         vert[ 1] = org1[1] + width * right1[1];
902         vert[ 2] = org1[2] + width * right1[2];
903         vert[ 3] = org1[0] - width * right1[0];
904         vert[ 4] = org1[1] - width * right1[1];
905         vert[ 5] = org1[2] - width * right1[2];
906         vert[ 6] = org2[0] - width * right2[0];
907         vert[ 7] = org2[1] - width * right2[1];
908         vert[ 8] = org2[2] - width * right2[2];
909         vert[ 9] = org2[0] + width * right2[0];
910         vert[10] = org2[1] + width * right2[1];
911         vert[11] = org2[2] + width * right2[2];
912 }
913
914 float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
915
916 void R_DrawSprite(int blendfunc1, int blendfunc2, rtexture_t *texture, int depthdisable, const vec3_t origin, const vec3_t left, const vec3_t up, float scalex1, float scalex2, float scaley1, float scaley2, float cr, float cg, float cb, float ca)
917 {
918         float diff[3];
919         rmeshstate_t m;
920
921         if (fogenabled)
922         {
923                 VectorSubtract(origin, r_vieworigin, diff);
924                 ca *= 1 - exp(fogdensity/DotProduct(diff,diff));
925         }
926
927         R_Mesh_Matrix(&r_identitymatrix);
928         GL_Color(cr, cg, cb, ca);
929         GL_VertexPointer(varray_vertex3f);
930         GL_BlendFunc(blendfunc1, blendfunc2);
931         GL_DepthMask(false);
932         GL_DepthTest(!depthdisable);
933
934         memset(&m, 0, sizeof(m));
935         m.tex[0] = R_GetTexture(texture);
936         m.pointer_texcoord[0] = spritetexcoord2f;
937         R_Mesh_State_Texture(&m);
938
939         varray_vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
940         varray_vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
941         varray_vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
942         varray_vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
943         varray_vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
944         varray_vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
945         varray_vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
946         varray_vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
947         varray_vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
948         varray_vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
949         varray_vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
950         varray_vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
951         R_Mesh_Draw(4, 2, polygonelements);
952 }
953