varray_* rewritten to remove padding (varray_vertex3f, varray_texcoord2f, varray_texc...
[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
24 // used for dlight push checking and other things
25 int r_framecount;
26
27 mplane_t frustum[4];
28
29 matrix4x4_t r_identitymatrix;
30
31 int c_alias_polys, c_light_polys, c_faces, c_nodes, c_leafs, c_models, c_bmodels, c_sprites, c_particles, c_dlights;
32
33 // true during envmap command capture
34 qboolean envmap;
35
36 float r_farclip;
37
38 // view origin
39 vec3_t r_origin;
40 vec3_t vpn;
41 vec3_t vright;
42 vec3_t vup;
43
44 //
45 // screen size info
46 //
47 refdef_t r_refdef;
48
49 // 8.8 fraction of base light value
50 unsigned short d_lightstylevalue[256];
51
52 cvar_t r_drawentities = {0, "r_drawentities","1"};
53 cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1"};
54 cvar_t r_shadows = {CVAR_SAVE, "r_shadows", "0"};
55 cvar_t r_shadow_staticworldlights = {0, "r_shadow_staticworldlights", "1"};
56 cvar_t r_speeds = {0, "r_speeds","0"};
57 cvar_t r_fullbright = {0, "r_fullbright","0"};
58 cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1"};
59 cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1"};
60 cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1"};
61 cvar_t r_shadow_cull = {0, "r_shadow_cull", "1"};
62
63 cvar_t gl_fogenable = {0, "gl_fogenable", "0"};
64 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25"};
65 cvar_t gl_fogred = {0, "gl_fogred","0.3"};
66 cvar_t gl_foggreen = {0, "gl_foggreen","0.3"};
67 cvar_t gl_fogblue = {0, "gl_fogblue","0.3"};
68 cvar_t gl_fogstart = {0, "gl_fogstart", "0"};
69 cvar_t gl_fogend = {0, "gl_fogend","0"};
70
71 cvar_t r_textureunits = {0, "r_textureunits", "32"};
72
73 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
74 {
75         int i;
76         for (i = 0;i < verts;i++)
77         {
78                 out[0] = in[0] * r;
79                 out[1] = in[1] * g;
80                 out[2] = in[2] * b;
81                 out[3] = in[3];
82                 in += 4;
83                 out += 4;
84         }
85 }
86
87 void R_FillColors(float *out, int verts, float r, float g, float b, float a)
88 {
89         int i;
90         for (i = 0;i < verts;i++)
91         {
92                 out[0] = r;
93                 out[1] = g;
94                 out[2] = b;
95                 out[3] = a;
96                 out += 4;
97         }
98 }
99
100 /*
101 ====================
102 R_TimeRefresh_f
103
104 For program optimization
105 ====================
106 */
107 qboolean intimerefresh = 0;
108 static void R_TimeRefresh_f (void)
109 {
110         int i;
111         float start, stop, time;
112
113         intimerefresh = 1;
114         start = Sys_DoubleTime ();
115         for (i = 0;i < 128;i++)
116         {
117                 r_refdef.viewangles[0] = 0;
118                 r_refdef.viewangles[1] = i/128.0*360.0;
119                 r_refdef.viewangles[2] = 0;
120                 CL_UpdateScreen();
121         }
122
123         stop = Sys_DoubleTime ();
124         intimerefresh = 0;
125         time = stop-start;
126         Con_Printf ("%f seconds (%f fps)\n", time, 128/time);
127 }
128
129 vec3_t fogcolor;
130 vec_t fogdensity;
131 float fog_density, fog_red, fog_green, fog_blue;
132 qboolean fogenabled;
133 qboolean oldgl_fogenable;
134 void R_SetupFog(void)
135 {
136         if (gamemode == GAME_NEHAHRA)
137         {
138                 if (gl_fogenable.integer)
139                 {
140                         oldgl_fogenable = true;
141                         fog_density = gl_fogdensity.value;
142                         fog_red = gl_fogred.value;
143                         fog_green = gl_foggreen.value;
144                         fog_blue = gl_fogblue.value;
145                 }
146                 else if (oldgl_fogenable)
147                 {
148                         oldgl_fogenable = false;
149                         fog_density = 0;
150                         fog_red = 0;
151                         fog_green = 0;
152                         fog_blue = 0;
153                 }
154         }
155         if (fog_density)
156         {
157                 fogcolor[0] = fog_red   = bound(0.0f, fog_red  , 1.0f);
158                 fogcolor[1] = fog_green = bound(0.0f, fog_green, 1.0f);
159                 fogcolor[2] = fog_blue  = bound(0.0f, fog_blue , 1.0f);
160         }
161         if (fog_density)
162         {
163                 fogenabled = true;
164                 fogdensity = -4000.0f / (fog_density * fog_density);
165                 // fog color was already set
166         }
167         else
168                 fogenabled = false;
169 }
170
171 // FIXME: move this to client?
172 void FOG_clear(void)
173 {
174         if (gamemode == GAME_NEHAHRA)
175         {
176                 Cvar_Set("gl_fogenable", "0");
177                 Cvar_Set("gl_fogdensity", "0.2");
178                 Cvar_Set("gl_fogred", "0.3");
179                 Cvar_Set("gl_foggreen", "0.3");
180                 Cvar_Set("gl_fogblue", "0.3");
181         }
182         fog_density = fog_red = fog_green = fog_blue = 0.0f;
183 }
184
185 // FIXME: move this to client?
186 void FOG_registercvars(void)
187 {
188         if (gamemode == GAME_NEHAHRA)
189         {
190                 Cvar_RegisterVariable (&gl_fogenable);
191                 Cvar_RegisterVariable (&gl_fogdensity);
192                 Cvar_RegisterVariable (&gl_fogred);
193                 Cvar_RegisterVariable (&gl_foggreen);
194                 Cvar_RegisterVariable (&gl_fogblue);
195                 Cvar_RegisterVariable (&gl_fogstart);
196                 Cvar_RegisterVariable (&gl_fogend);
197         }
198 }
199
200 void gl_main_start(void)
201 {
202 }
203
204 void gl_main_shutdown(void)
205 {
206 }
207
208 extern void CL_ParseEntityLump(char *entitystring);
209 void gl_main_newmap(void)
210 {
211         if (cl.worldmodel && cl.worldmodel->entities)
212                 CL_ParseEntityLump(cl.worldmodel->entities);
213         r_framecount = 1;
214 }
215
216 void GL_Main_Init(void)
217 {
218         Matrix4x4_CreateIdentity(&r_identitymatrix);
219 // FIXME: move this to client?
220         FOG_registercvars();
221         Cmd_AddCommand ("timerefresh", R_TimeRefresh_f);
222         Cvar_RegisterVariable (&r_drawentities);
223         Cvar_RegisterVariable (&r_drawviewmodel);
224         Cvar_RegisterVariable (&r_shadows);
225         Cvar_RegisterVariable (&r_shadow_staticworldlights);
226         Cvar_RegisterVariable (&r_speeds);
227         Cvar_RegisterVariable (&r_fullbrights);
228         Cvar_RegisterVariable (&r_wateralpha);
229         Cvar_RegisterVariable (&r_dynamic);
230         Cvar_RegisterVariable (&r_fullbright);
231         Cvar_RegisterVariable (&r_textureunits);
232         Cvar_RegisterVariable (&r_shadow_cull);
233         if (gamemode == GAME_NEHAHRA || gamemode == GAME_NEXIUZ)
234                 Cvar_SetValue("r_fullbrights", 0);
235         R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap);
236 }
237
238 vec3_t r_farclip_origin;
239 vec3_t r_farclip_direction;
240 vec_t r_farclip_directiondist;
241 vec_t r_farclip_meshfarclip;
242 int r_farclip_directionbit0;
243 int r_farclip_directionbit1;
244 int r_farclip_directionbit2;
245
246 // start a farclip measuring session
247 void R_FarClip_Start(vec3_t origin, vec3_t direction, vec_t startfarclip)
248 {
249         VectorCopy(origin, r_farclip_origin);
250         VectorCopy(direction, r_farclip_direction);
251         r_farclip_directiondist = DotProduct(r_farclip_origin, r_farclip_direction);
252         r_farclip_directionbit0 = r_farclip_direction[0] < 0;
253         r_farclip_directionbit1 = r_farclip_direction[1] < 0;
254         r_farclip_directionbit2 = r_farclip_direction[2] < 0;
255         r_farclip_meshfarclip = r_farclip_directiondist + startfarclip;
256 }
257
258 // enlarge farclip to accomodate box
259 void R_FarClip_Box(vec3_t mins, vec3_t maxs)
260 {
261         float d;
262         d = (r_farclip_directionbit0 ? mins[0] : maxs[0]) * r_farclip_direction[0]
263           + (r_farclip_directionbit1 ? mins[1] : maxs[1]) * r_farclip_direction[1]
264           + (r_farclip_directionbit2 ? mins[2] : maxs[2]) * r_farclip_direction[2];
265         if (r_farclip_meshfarclip < d)
266                 r_farclip_meshfarclip = d;
267 }
268
269 // return farclip value
270 float R_FarClip_Finish(void)
271 {
272         return r_farclip_meshfarclip - r_farclip_directiondist;
273 }
274
275 /*
276 ===============
277 R_NewMap
278 ===============
279 */
280 void R_NewMap (void)
281 {
282         R_Modules_NewMap();
283 }
284
285 extern void R_Textures_Init(void);
286 extern void Mod_RenderInit(void);
287 extern void GL_Draw_Init(void);
288 extern void GL_Main_Init(void);
289 extern void R_Shadow_Init(void);
290 extern void GL_Models_Init(void);
291 extern void R_Sky_Init(void);
292 extern void GL_Surf_Init(void);
293 extern void R_Crosshairs_Init(void);
294 extern void R_Light_Init(void);
295 extern void R_Particles_Init(void);
296 extern void R_Explosion_Init(void);
297 extern void ui_init(void);
298 extern void gl_backend_init(void);
299 extern void Sbar_Init(void);
300
301 void Render_Init(void)
302 {
303         R_Textures_Init();
304         Mod_RenderInit();
305         gl_backend_init();
306         R_MeshQueue_Init();
307         GL_Draw_Init();
308         GL_Main_Init();
309         R_Shadow_Init();
310         GL_Models_Init();
311         R_Sky_Init();
312         GL_Surf_Init();
313         R_Crosshairs_Init();
314         R_Light_Init();
315         R_Particles_Init();
316         R_Explosion_Init();
317         ui_init();
318         Sbar_Init();
319 }
320
321 /*
322 ===============
323 GL_Init
324 ===============
325 */
326 extern char *ENGINE_EXTENSIONS;
327 void GL_Init (void)
328 {
329         VID_CheckExtensions();
330
331         // LordHavoc: report supported extensions
332         Con_Printf ("\nengine extensions: %s\n", ENGINE_EXTENSIONS);
333 }
334
335 int R_CullBox(const vec3_t mins, const vec3_t maxs)
336 {
337         int i;
338         mplane_t *p;
339         for (i = 0;i < 4;i++)
340         {
341                 p = frustum + i;
342                 switch(p->signbits)
343                 {
344                 default:
345                 case 0:
346                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
347                                 return true;
348                         break;
349                 case 1:
350                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
351                                 return true;
352                         break;
353                 case 2:
354                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
355                                 return true;
356                         break;
357                 case 3:
358                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
359                                 return true;
360                         break;
361                 case 4:
362                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
363                                 return true;
364                         break;
365                 case 5:
366                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
367                                 return true;
368                         break;
369                 case 6:
370                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
371                                 return true;
372                         break;
373                 case 7:
374                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
375                                 return true;
376                         break;
377                 }
378         }
379         return false;
380 }
381
382 int PVS_CullBox(const vec3_t mins, const vec3_t maxs)
383 {
384         int stackpos, sides;
385         mnode_t *node, *stack[4096];
386         if (cl.worldmodel == NULL)
387                 return false;
388         stackpos = 0;
389         stack[stackpos++] = cl.worldmodel->nodes;
390         while (stackpos)
391         {
392                 node = stack[--stackpos];
393                 if (node->contents < 0)
394                 {
395                         if (((mleaf_t *)node)->pvsframe == cl.worldmodel->pvsframecount)
396                                 return false;
397                 }
398                 else
399                 {
400                         sides = BoxOnPlaneSide(mins, maxs, node->plane);
401                         if (sides & 2 && stackpos < 4096)
402                                 stack[stackpos++] = node->children[1];
403                         if (sides & 1 && stackpos < 4096)
404                                 stack[stackpos++] = node->children[0];
405                 }
406         }
407         return true;
408 }
409
410 int VIS_CullBox(const vec3_t mins, const vec3_t maxs)
411 {
412         int stackpos, sides;
413         mnode_t *node, *stack[4096];
414         if (R_CullBox(mins, maxs))
415                 return true;
416         if (cl.worldmodel == NULL)
417                 return false;
418         stackpos = 0;
419         stack[stackpos++] = cl.worldmodel->nodes;
420         while (stackpos)
421         {
422                 node = stack[--stackpos];
423                 if (node->contents < 0)
424                 {
425                         if (((mleaf_t *)node)->visframe == r_framecount)
426                                 return false;
427                 }
428                 else
429                 {
430                         sides = BoxOnPlaneSide(mins, maxs, node->plane);
431                         if (sides & 2 && stackpos < 4096)
432                                 stack[stackpos++] = node->children[1];
433                         if (sides & 1 && stackpos < 4096)
434                                 stack[stackpos++] = node->children[0];
435                 }
436         }
437         return true;
438 }
439
440 int R_CullSphere(const vec3_t origin, vec_t radius)
441 {
442         return (DotProduct(frustum[0].normal, origin) + radius < frustum[0].dist
443              || DotProduct(frustum[1].normal, origin) + radius < frustum[1].dist
444              || DotProduct(frustum[2].normal, origin) + radius < frustum[2].dist
445              || DotProduct(frustum[3].normal, origin) + radius < frustum[3].dist);
446 }
447
448 int PVS_CullSphere(const vec3_t origin, vec_t radius)
449 {
450         int stackpos;
451         mnode_t *node, *stack[4096];
452         float dist;
453         if (cl.worldmodel == NULL)
454                 return false;
455         stackpos = 0;
456         stack[stackpos++] = cl.worldmodel->nodes;
457         while (stackpos)
458         {
459                 node = stack[--stackpos];
460                 if (node->contents < 0)
461                 {
462                         if (((mleaf_t *)node)->pvsframe == cl.worldmodel->pvsframecount)
463                                 return false;
464                 }
465                 else
466                 {
467                         dist = PlaneDiff(origin, node->plane);
468                         if (dist <= radius)
469                                 stack[stackpos++] = node->children[1];
470                         if (dist >= -radius)
471                                 stack[stackpos++] = node->children[0];
472                 }
473         }
474         return true;
475 }
476
477 int VIS_CullSphere(const vec3_t origin, vec_t radius)
478 {
479         int stackpos;
480         mnode_t *node, *stack[4096];
481         float dist;
482         if (R_CullSphere(origin, radius))
483                 return true;
484         if (cl.worldmodel == NULL)
485                 return false;
486         stackpos = 0;
487         stack[stackpos++] = cl.worldmodel->nodes;
488         while (stackpos)
489         {
490                 node = stack[--stackpos];
491                 if (node->contents < 0)
492                 {
493                         if (((mleaf_t *)node)->visframe == r_framecount)
494                                 return false;
495                 }
496                 else
497                 {
498                         dist = PlaneDiff(origin, node->plane);
499                         if (dist <= radius)
500                                 stack[stackpos++] = node->children[1];
501                         if (dist >= -radius)
502                                 stack[stackpos++] = node->children[0];
503                 }
504         }
505         return true;
506 }
507
508
509 //==================================================================================
510
511 static void R_MarkEntities (void)
512 {
513         int i;
514         entity_render_t *ent;
515
516         ent = &cl_entities[0].render;
517         Matrix4x4_CreateIdentity(&ent->matrix);
518         Matrix4x4_CreateIdentity(&ent->inversematrix);
519
520         if (cl.worldmodel)
521                 R_FarClip_Box(cl.worldmodel->normalmins, cl.worldmodel->normalmaxs);
522
523         if (!r_drawentities.integer)
524                 return;
525
526         for (i = 0;i < r_refdef.numentities;i++)
527         {
528                 ent = r_refdef.entities[i];
529                 Mod_CheckLoaded(ent->model);
530                 // some of the renderer still relies on origin...
531                 Matrix4x4_OriginFromMatrix(&ent->matrix, ent->origin);
532                 // some of the renderer still relies on scale...
533                 ent->scale = Matrix4x4_ScaleFromMatrix(&ent->matrix);
534                 R_LerpAnimation(ent);
535                 R_UpdateEntLights(ent);
536                 if ((chase_active.integer || !(ent->flags & RENDER_EXTERIORMODEL))
537                  && !VIS_CullSphere(ent->origin, (ent->model != NULL ? ent->model->radius : 16) * ent->scale)
538                  && !VIS_CullBox(ent->mins, ent->maxs))
539                 {
540                         ent->visframe = r_framecount;
541                         R_FarClip_Box(ent->mins, ent->maxs);
542                 }
543         }
544 }
545
546 // only used if skyrendermasked, and normally returns false
547 int R_DrawBrushModelsSky (void)
548 {
549         int i, sky;
550         entity_render_t *ent;
551
552         if (!r_drawentities.integer)
553                 return false;
554
555         sky = false;
556         for (i = 0;i < r_refdef.numentities;i++)
557         {
558                 ent = r_refdef.entities[i];
559                 if (ent->visframe == r_framecount && ent->model && ent->model->DrawSky)
560                 {
561                         ent->model->DrawSky(ent);
562                         sky = true;
563                 }
564         }
565         return sky;
566 }
567
568 /*
569 =============
570 R_DrawViewModel
571 =============
572 */
573 /*
574 void R_DrawViewModel (void)
575 {
576         entity_render_t *ent;
577
578         // FIXME: move these checks to client
579         if (!r_drawviewmodel.integer || chase_active.integer || envmap || !r_drawentities.integer || cl.items & IT_INVISIBILITY || cl.stats[STAT_HEALTH] <= 0 || !cl.viewent.render.model)
580                 return;
581
582         ent = &cl.viewent.render;
583         Mod_CheckLoaded(ent->model);
584         R_LerpAnimation(ent);
585         Matrix4x4_CreateFromQuakeEntity(&ent->matrix, ent->origin[0], ent->origin[1], ent->origin[2], -ent->angles[0], ent->angles[1], ent->angles[2], ent->scale);
586         Matrix4x4_Invert_Simple(&ent->inversematrix, &ent->matrix);
587         R_UpdateEntLights(ent);
588         ent->model->Draw(ent);
589 }
590 */
591
592 void R_DrawNoModel(entity_render_t *ent);
593 void R_DrawModels ()
594 {
595         int i;
596         entity_render_t *ent;
597
598         if (!r_drawentities.integer)
599                 return;
600
601         for (i = 0;i < r_refdef.numentities;i++)
602         {
603                 ent = r_refdef.entities[i];
604                 if (ent->visframe == r_framecount)
605                 {
606                         if (ent->model && ent->model->Draw != NULL)
607                                 ent->model->Draw(ent);
608                         else
609                                 R_DrawNoModel(ent);
610                 }
611         }
612 }
613
614 void R_DrawFakeShadows (void)
615 {
616         int i;
617         entity_render_t *ent;
618
619         ent = &cl_entities[0].render;
620         if (ent->model && ent->model->DrawFakeShadow)
621                 ent->model->DrawFakeShadow(ent);
622
623         if (!r_drawentities.integer)
624                 return;
625         for (i = 0;i < r_refdef.numentities;i++)
626         {
627                 ent = r_refdef.entities[i];
628                 if ((ent->flags & RENDER_SHADOW) && ent->model && ent->model->DrawFakeShadow)
629                         ent->model->DrawFakeShadow(ent);
630         }
631 }
632
633 #include "r_shadow.h"
634
635 int shadowframecount = 0;
636
637 int Light_CullBox(const vec3_t mins, const vec3_t maxs)
638 {
639         int stackpos, sides;
640         mnode_t *node, *stack[4096];
641         if (cl.worldmodel == NULL)
642                 return false;
643         stackpos = 0;
644         stack[stackpos++] = cl.worldmodel->nodes;
645         while (stackpos)
646         {
647                 node = stack[--stackpos];
648                 if (node->contents < 0)
649                 {
650                         if (((mleaf_t *)node)->worldnodeframe == shadowframecount)
651                                 return false;
652                 }
653                 else
654                 {
655                         sides = BoxOnPlaneSide(mins, maxs, node->plane);
656                         if (sides & 2 && stackpos < 4096)
657                                 stack[stackpos++] = node->children[1];
658                         if (sides & 1 && stackpos < 4096)
659                                 stack[stackpos++] = node->children[0];
660                 }
661         }
662         return true;
663 }
664
665 int LightAndVis_CullBox(const vec3_t mins, const vec3_t maxs)
666 {
667         int stackpos, sides;
668         mnode_t *node, *stack[4096];
669         if (R_CullBox(mins, maxs))
670                 return true;
671         if (cl.worldmodel == NULL)
672                 return false;
673         stackpos = 0;
674         stack[stackpos++] = cl.worldmodel->nodes;
675         while (stackpos)
676         {
677                 node = stack[--stackpos];
678                 if (node->contents < 0)
679                 {
680                         if (((mleaf_t *)node)->visframe == r_framecount && ((mleaf_t *)node)->worldnodeframe == shadowframecount)
681                                 return false;
682                 }
683                 else
684                 {
685                         sides = BoxOnPlaneSide(mins, maxs, node->plane);
686                         if (sides & 2 && stackpos < 4096)
687                                 stack[stackpos++] = node->children[1];
688                         if (sides & 1 && stackpos < 4096)
689                                 stack[stackpos++] = node->children[0];
690                 }
691         }
692         return true;
693 }
694
695 int LightAndVis_CullPointCloud(int numpoints, const float *points)
696 {
697         int i;
698         const float *p;
699         int stackpos, sides;
700         mnode_t *node, *stack[4096];
701         //if (R_CullBox(mins, maxs))
702         //      return true;
703         if (cl.worldmodel == NULL)
704                 return false;
705         stackpos = 0;
706         stack[stackpos++] = cl.worldmodel->nodes;
707         while (stackpos)
708         {
709                 node = stack[--stackpos];
710                 if (node->contents < 0)
711                 {
712                         if (((mleaf_t *)node)->visframe == r_framecount && ((mleaf_t *)node)->worldnodeframe == shadowframecount)
713                                 return false;
714                 }
715                 else
716                 {
717                         sides = 0;
718                         for (i = 0, p = points;i < numpoints && sides != 3;i++, p += 3)
719                         {
720                                 if (DotProduct(p, node->plane->normal) < node->plane->dist)
721                                         sides |= 1;
722                                 else
723                                         sides |= 2;
724                         }
725                         if (sides & 2 && stackpos < 4096)
726                                 stack[stackpos++] = node->children[1];
727                         if (sides & 1 && stackpos < 4096)
728                                 stack[stackpos++] = node->children[0];
729                 }
730         }
731         return true;
732 }
733
734
735 void R_TestAndDrawShadowVolume(entity_render_t *ent, vec3_t lightorigin, float cullradius, float lightradius, vec3_t lightmins, vec3_t lightmaxs, vec3_t clipmins, vec3_t clipmaxs)
736 {
737         vec3_t relativelightorigin;
738         #if 0
739         int i;
740         vec3_t temp;
741         float dist, projectdistance;
742         float points[16][3];
743         #endif
744         // rough checks
745         if (!(ent->flags & RENDER_SHADOW) || ent->model == NULL || ent->model->DrawShadowVolume == NULL)
746                 return;
747         if (r_shadow_cull.integer)
748         {
749                 if (ent->maxs[0] < lightmins[0] || ent->mins[0] > lightmaxs[0]
750                  || ent->maxs[1] < lightmins[1] || ent->mins[1] > lightmaxs[1]
751                  || ent->maxs[2] < lightmins[2] || ent->mins[2] > lightmaxs[2]
752                  || Light_CullBox(ent->mins, ent->maxs))
753                         return;
754         }
755         #if 0
756         if (r_shadow_cull.integer)
757         {
758                 projectdistance = cullradius;
759                 // calculate projected bounding box and decide if it is on-screen
760                 for (i = 0;i < 8;i++)
761                 {
762                         temp[0] = i & 1 ? ent->model->normalmaxs[0] : ent->model->normalmins[0];
763                         temp[1] = i & 2 ? ent->model->normalmaxs[1] : ent->model->normalmins[1];
764                         temp[2] = i & 4 ? ent->model->normalmaxs[2] : ent->model->normalmins[2];
765                         Matrix4x4_Transform(&ent->matrix, temp, points[i]);
766                         VectorSubtract(points[i], lightorigin, temp);
767                         dist = projectdistance / sqrt(DotProduct(temp, temp));
768                         VectorMA(points[i], dist, temp, points[i+8]);
769                 }
770                 if (LightAndVis_CullPointCloud(16, points[0]))
771                         return;
772                 /*
773                 for (i = 0;i < 8;i++)
774                 {
775                         p2[0] = i & 1 ? ent->model->normalmaxs[0] : ent->model->normalmins[0];
776                         p2[1] = i & 2 ? ent->model->normalmaxs[1] : ent->model->normalmins[1];
777                         p2[2] = i & 4 ? ent->model->normalmaxs[2] : ent->model->normalmins[2];
778                         Matrix4x4_Transform(&ent->matrix, p2, p);
779                         VectorSubtract(p, lightorigin, temp);
780                         dist = projectdistance / sqrt(DotProduct(temp, temp));
781                         VectorMA(p, dist, temp, p2);
782                         if (i)
783                         {
784                                 if (mins[0] > p[0]) mins[0] = p[0];if (maxs[0] < p[0]) maxs[0] = p[0];
785                                 if (mins[1] > p[1]) mins[1] = p[1];if (maxs[1] < p[1]) maxs[1] = p[1];
786                                 if (mins[2] > p[2]) mins[2] = p[2];if (maxs[2] < p[2]) maxs[2] = p[2];
787                         }
788                         else
789                         {
790                                 VectorCopy(p, mins);
791                                 VectorCopy(p, maxs);
792                         }
793                         if (mins[0] > p2[0]) mins[0] = p2[0];if (maxs[0] < p2[0]) maxs[0] = p2[0];
794                         if (mins[1] > p2[1]) mins[1] = p2[1];if (maxs[1] < p2[1]) maxs[1] = p2[1];
795                         if (mins[2] > p2[2]) mins[2] = p2[2];if (maxs[2] < p2[2]) maxs[2] = p2[2];
796                 }
797                 if (mins[0] >= clipmaxs[0] || maxs[0] <= clipmins[0]
798                  || mins[1] >= clipmaxs[1] || maxs[1] <= clipmins[1]
799                  || mins[2] >= clipmaxs[2] || maxs[2] <= clipmins[2]
800                  || LightAndVis_CullBox(mins, maxs))
801                         return;
802                 */
803         }
804         #endif
805         Matrix4x4_Transform(&ent->inversematrix, lightorigin, relativelightorigin);
806         ent->model->DrawShadowVolume (ent, relativelightorigin, lightradius);
807 }
808
809 void R_Shadow_DrawWorldLightShadowVolume(matrix4x4_t *matrix, worldlight_t *light);
810
811 extern void R_Model_Brush_DrawLightForSurfaceList(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, msurface_t **surflist, int numsurfaces, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz);
812 void R_ShadowVolumeLighting (int visiblevolumes)
813 {
814         int i;
815         entity_render_t *ent;
816         int lnum;
817         float f, lightradius, cullradius;
818         vec3_t relativelightorigin, relativeeyeorigin, lightcolor, clipmins, clipmaxs;
819         worldlight_t *wl;
820         rdlight_t *rd;
821         rmeshstate_t m;
822         mleaf_t *leaf;
823         matrix4x4_t matrix;
824         matrix4x4_t matrix_worldtofilter, matrix_worldtoattenuationxyz, matrix_worldtoattenuationz;
825         matrix4x4_t matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz;
826
827         if (visiblevolumes)
828         {
829                 memset(&m, 0, sizeof(m));
830                 m.blendfunc1 = GL_ONE;
831                 m.blendfunc2 = GL_ONE;
832                 if (r_shadow_realtime.integer >= 3)
833                         m.depthdisable = true;
834                 R_Mesh_State(&m);
835                 qglDisable(GL_CULL_FACE);
836                 GL_Color(0.0 * r_colorscale, 0.0125 * r_colorscale, 0.1 * r_colorscale, 1);
837         }
838         else
839                 R_Shadow_Stage_Begin();
840         shadowframecount++;
841         for (lnum = 0, wl = r_shadow_worldlightchain;wl;wl = wl->next, lnum++)
842         {
843                 if (d_lightstylevalue[wl->style] <= 0)
844                         continue;
845                 if (R_CullBox(wl->mins, wl->maxs))
846                 //if (R_CullSphere(wl->origin, cullradius))
847                         continue;
848                 //if (R_CullBox(wl->mins, wl->maxs) || R_CullSphere(wl->origin, lightradius))
849                 //      continue;
850                 //if (VIS_CullBox(wl->mins, wl->maxs) || VIS_CullSphere(wl->origin, lightradius))
851                 //      continue;
852                 if (r_shadow_debuglight.integer >= 0 && lnum != r_shadow_debuglight.integer)
853                         continue;
854
855                 cullradius = wl->cullradius;
856                 lightradius = wl->lightradius;
857
858                 if (cl.worldmodel != NULL)
859                 {
860                         for (i = 0;i < wl->numleafs;i++)
861                                 if (wl->leafs[i]->visframe == r_framecount)
862                                         break;
863                         if (i == wl->numleafs)
864                                 continue;
865                         leaf = wl->leafs[i++];
866                         VectorCopy(leaf->mins, clipmins);
867                         VectorCopy(leaf->maxs, clipmaxs);
868                         for (;i < wl->numleafs;i++)
869                         {
870                                 leaf = wl->leafs[i];
871                                 if (leaf->visframe == r_framecount)
872                                 {
873                                         if (clipmins[0] > leaf->mins[0]) clipmins[0] = leaf->mins[0];
874                                         if (clipmaxs[0] < leaf->maxs[0]) clipmaxs[0] = leaf->maxs[0];
875                                         if (clipmins[1] > leaf->mins[1]) clipmins[1] = leaf->mins[1];
876                                         if (clipmaxs[1] < leaf->maxs[1]) clipmaxs[1] = leaf->maxs[1];
877                                         if (clipmins[2] > leaf->mins[2]) clipmins[2] = leaf->mins[2];
878                                         if (clipmaxs[2] < leaf->maxs[2]) clipmaxs[2] = leaf->maxs[2];
879                                 }
880                         }
881                         if (clipmins[0] < wl->mins[0]) clipmins[0] = wl->mins[0];
882                         if (clipmaxs[0] > wl->maxs[0]) clipmaxs[0] = wl->maxs[0];
883                         if (clipmins[1] < wl->mins[1]) clipmins[1] = wl->mins[1];
884                         if (clipmaxs[1] > wl->maxs[1]) clipmaxs[1] = wl->maxs[1];
885                         if (clipmins[2] < wl->mins[2]) clipmins[2] = wl->mins[2];
886                         if (clipmaxs[2] > wl->maxs[2]) clipmaxs[2] = wl->maxs[2];
887                 }
888                 else
889                 {
890                         VectorCopy(wl->mins, clipmins);
891                         VectorCopy(wl->maxs, clipmaxs);
892                 }
893
894                 //if (R_Shadow_ScissorForBBoxAndSphere(clipmins, clipmaxs, wl->origin, wl->cullradius))
895                 if (R_CullBox(clipmins, clipmaxs) || R_Shadow_ScissorForBBox(clipmins, clipmaxs))
896                         continue;
897
898                 // mark the leafs we care about so only things in those leafs will matter
899                 if (cl.worldmodel != NULL)
900                         for (i = 0;i < wl->numleafs;i++)
901                                 wl->leafs[i]->worldnodeframe = shadowframecount;
902
903                 f = d_lightstylevalue[wl->style] * (1.0f / 256.0f);
904                 VectorScale(wl->light, f, lightcolor);
905                 if (wl->selected)
906                 {
907                         f = 2 + sin(realtime * M_PI * 4.0);
908                         VectorScale(lightcolor, f, lightcolor);
909                 }
910
911                 if (wl->castshadows)
912                 {
913                         if (!visiblevolumes)
914                                 R_Shadow_Stage_ShadowVolumes();
915                         ent = &cl_entities[0].render;
916                         if (wl->shadowvolume && r_shadow_staticworldlights.integer)
917                                 R_Shadow_DrawWorldLightShadowVolume(&ent->matrix, wl);
918                         else
919                                 R_TestAndDrawShadowVolume(ent, wl->origin, cullradius, lightradius, wl->mins, wl->maxs, clipmins, clipmaxs);
920                         if (r_drawentities.integer)
921                                 for (i = 0;i < r_refdef.numentities;i++)
922                                         R_TestAndDrawShadowVolume(r_refdef.entities[i], wl->origin, cullradius, lightradius, wl->mins, wl->maxs, clipmins, clipmaxs);
923                 }
924
925                 if (!visiblevolumes)
926                 {
927                         if (wl->castshadows)
928                                 R_Shadow_Stage_LightWithShadows();
929                         else
930                                 R_Shadow_Stage_LightWithoutShadows();
931
932                         // calculate world to filter matrix
933                         Matrix4x4_CreateFromQuakeEntity(&matrix, wl->origin[0], wl->origin[1], wl->origin[2], wl->angles[0], wl->angles[1], wl->angles[2], lightradius);
934                         Matrix4x4_Invert_Simple(&matrix_worldtofilter, &matrix);
935                         // calculate world to attenuationxyz/xy matrix
936                         Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5, 0.5, 0.5, 0, 0, 0, 0.5);
937                         Matrix4x4_Concat(&matrix_worldtoattenuationxyz, &matrix, &matrix_worldtofilter);
938                         // calculate world to attenuationz matrix
939                         matrix.m[0][0] = 0;matrix.m[0][1] = 0;matrix.m[0][2] = 0.5;matrix.m[0][3] = 0.5;
940                         matrix.m[1][0] = 0;matrix.m[1][1] = 0;matrix.m[1][2] = 0  ;matrix.m[1][3] = 0.5;
941                         matrix.m[2][0] = 0;matrix.m[2][1] = 0;matrix.m[2][2] = 0  ;matrix.m[2][3] = 0.5;
942                         matrix.m[3][0] = 0;matrix.m[3][1] = 0;matrix.m[3][2] = 0  ;matrix.m[3][3] = 1;
943                         Matrix4x4_Concat(&matrix_worldtoattenuationz, &matrix, &matrix_worldtofilter);
944
945                         ent = &cl_entities[0].render;
946                         if (ent->model && ent->model->DrawLight)
947                         {
948                                 Matrix4x4_Transform(&ent->inversematrix, wl->origin, relativelightorigin);
949                                 Matrix4x4_Transform(&ent->inversematrix, r_origin, relativeeyeorigin);
950                                 Matrix4x4_Concat(&matrix_modeltofilter, &matrix_worldtofilter, &ent->matrix);
951                                 Matrix4x4_Concat(&matrix_modeltoattenuationxyz, &matrix_worldtoattenuationxyz, &ent->matrix);
952                                 Matrix4x4_Concat(&matrix_modeltoattenuationz, &matrix_worldtoattenuationz, &ent->matrix);
953                                 if (wl->numsurfaces)
954                                         R_Model_Brush_DrawLightForSurfaceList(ent, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, wl->surfaces, wl->numsurfaces, &matrix_modeltofilter, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz);
955                                 else
956                                         ent->model->DrawLight(ent, relativelightorigin, relativeeyeorigin, lightradius / ent->scale, lightcolor, &matrix_modeltofilter, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz);
957                         }
958                         if (r_drawentities.integer)
959                         {
960                                 for (i = 0;i < r_refdef.numentities;i++)
961                                 {
962                                         ent = r_refdef.entities[i];
963                                         if (ent->visframe == r_framecount && ent->model && ent->model->DrawLight
964                                          && ent->maxs[0] >= clipmins[0] && ent->mins[0] <= clipmaxs[0]
965                                          && ent->maxs[1] >= clipmins[1] && ent->mins[1] <= clipmaxs[1]
966                                          && ent->maxs[2] >= clipmins[2] && ent->mins[2] <= clipmaxs[2]
967                                          && !(ent->effects & EF_ADDITIVE) && ent->alpha == 1)
968                                         {
969                                                 Matrix4x4_Transform(&ent->inversematrix, wl->origin, relativelightorigin);
970                                                 Matrix4x4_Transform(&ent->inversematrix, r_origin, relativeeyeorigin);
971                                                 Matrix4x4_Concat(&matrix_modeltofilter, &matrix_worldtofilter, &ent->matrix);
972                                                 Matrix4x4_Concat(&matrix_modeltoattenuationxyz, &matrix_worldtoattenuationxyz, &ent->matrix);
973                                                 Matrix4x4_Concat(&matrix_modeltoattenuationz, &matrix_worldtoattenuationz, &ent->matrix);
974                                                 ent->model->DrawLight(ent, relativelightorigin, relativeeyeorigin, lightradius / ent->scale, lightcolor, &matrix_modeltofilter, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz);
975                                         }
976                                 }
977                         }
978                 }
979         }
980         for (lnum = 0, rd = r_dlight;lnum < r_numdlights;lnum++, rd++)
981         {
982                 lightradius = rd->cullradius;
983                 clipmins[0] = rd->origin[0] - lightradius;
984                 clipmins[1] = rd->origin[1] - lightradius;
985                 clipmins[2] = rd->origin[2] - lightradius;
986                 clipmaxs[0] = rd->origin[0] + lightradius;
987                 clipmaxs[1] = rd->origin[1] + lightradius;
988                 clipmaxs[2] = rd->origin[2] + lightradius;
989                 if (VIS_CullBox(clipmins, clipmaxs))
990                         continue;
991
992                 //if (R_Shadow_ScissorForBBoxAndSphere(clipmins, clipmaxs, rd->origin, cullradius))
993                 if (R_Shadow_ScissorForBBox(clipmins, clipmaxs))
994                         continue;
995
996                 if (!visiblevolumes)
997                         R_Shadow_Stage_ShadowVolumes();
998
999                 cullradius = RadiusFromBoundsAndOrigin(clipmins, clipmaxs, rd->origin);
1000                 VectorScale(rd->light, (1.0f / 4096.0f), lightcolor);
1001
1002                 ent = &cl_entities[0].render;
1003                 R_TestAndDrawShadowVolume(ent, rd->origin, cullradius, lightradius, clipmins, clipmaxs, clipmins, clipmaxs);
1004                 if (r_drawentities.integer)
1005                 {
1006                         for (i = 0;i < r_refdef.numentities;i++)
1007                         {
1008                                 ent = r_refdef.entities[i];
1009                                 if (ent != rd->ent)
1010                                         R_TestAndDrawShadowVolume(ent, rd->origin, cullradius, lightradius, clipmins, clipmaxs, clipmins, clipmaxs);
1011                         }
1012                 }
1013
1014                 if (!visiblevolumes)
1015                 {
1016                         R_Shadow_Stage_LightWithShadows();
1017
1018                         // calculate world to filter matrix
1019                         Matrix4x4_CreateFromQuakeEntity(&matrix, rd->origin[0], rd->origin[1], rd->origin[2], 0, 0, 0, lightradius);
1020                         Matrix4x4_Invert_Simple(&matrix_worldtofilter, &matrix);
1021                         // calculate world to attenuationxyz/xy matrix
1022                         Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5, 0.5, 0.5, 0, 0, 0, 0.5);
1023                         Matrix4x4_Concat(&matrix_worldtoattenuationxyz, &matrix, &matrix_worldtofilter);
1024                         // calculate world to attenuationz matrix
1025                         matrix.m[0][0] = 0;matrix.m[0][1] = 0;matrix.m[0][2] = 0.5;matrix.m[0][3] = 0.5;
1026                         matrix.m[1][0] = 0;matrix.m[1][1] = 0;matrix.m[1][2] = 0  ;matrix.m[1][3] = 0.5;
1027                         matrix.m[2][0] = 0;matrix.m[2][1] = 0;matrix.m[2][2] = 0  ;matrix.m[2][3] = 0.5;
1028                         matrix.m[3][0] = 0;matrix.m[3][1] = 0;matrix.m[3][2] = 0  ;matrix.m[3][3] = 1;
1029                         Matrix4x4_Concat(&matrix_worldtoattenuationz, &matrix, &matrix_worldtofilter);
1030
1031                         ent = &cl_entities[0].render;
1032                         if (ent->model && ent->model->DrawLight)
1033                         {
1034                                 Matrix4x4_Transform(&ent->inversematrix, rd->origin, relativelightorigin);
1035                                 Matrix4x4_Transform(&ent->inversematrix, r_origin, relativeeyeorigin);
1036                                 Matrix4x4_Concat(&matrix_modeltofilter, &matrix_worldtofilter, &ent->matrix);
1037                                 Matrix4x4_Concat(&matrix_modeltoattenuationxyz, &matrix_worldtoattenuationxyz, &ent->matrix);
1038                                 Matrix4x4_Concat(&matrix_modeltoattenuationz, &matrix_worldtoattenuationz, &ent->matrix);
1039                                 ent->model->DrawLight(ent, relativelightorigin, relativeeyeorigin, lightradius / ent->scale, lightcolor, &matrix_modeltofilter, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz);
1040                         }
1041                         if (r_drawentities.integer)
1042                         {
1043                                 for (i = 0;i < r_refdef.numentities;i++)
1044                                 {
1045                                         ent = r_refdef.entities[i];
1046                                         if (ent->visframe == r_framecount && ent->model && ent->model->DrawLight
1047                                          && ent->maxs[0] >= clipmins[0] && ent->mins[0] <= clipmaxs[0]
1048                                          && ent->maxs[1] >= clipmins[1] && ent->mins[1] <= clipmaxs[1]
1049                                          && ent->maxs[2] >= clipmins[2] && ent->mins[2] <= clipmaxs[2]
1050                                          && !(ent->effects & EF_ADDITIVE) && ent->alpha == 1)
1051                                         {
1052                                                 Matrix4x4_Transform(&ent->inversematrix, rd->origin, relativelightorigin);
1053                                                 Matrix4x4_Transform(&ent->inversematrix, r_origin, relativeeyeorigin);
1054                                                 Matrix4x4_Concat(&matrix_modeltofilter, &matrix_worldtofilter, &ent->matrix);
1055                                                 Matrix4x4_Concat(&matrix_modeltoattenuationxyz, &matrix_worldtoattenuationxyz, &ent->matrix);
1056                                                 Matrix4x4_Concat(&matrix_modeltoattenuationz, &matrix_worldtoattenuationz, &ent->matrix);
1057                                                 ent->model->DrawLight(ent, relativelightorigin, relativeeyeorigin, lightradius / ent->scale, lightcolor, &matrix_modeltofilter, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz);
1058                                         }
1059                                 }
1060                         }
1061                 }
1062         }
1063
1064         if (!visiblevolumes)
1065                 R_Shadow_Stage_End();
1066         qglEnable(GL_CULL_FACE);
1067         qglDisable(GL_SCISSOR_TEST);
1068 }
1069
1070 static void R_SetFrustum (void)
1071 {
1072         // LordHavoc: note to all quake engine coders, the special case for 90
1073         // degrees assumed a square view (wrong), so I removed it, Quake2 has it
1074         // disabled as well.
1075
1076         // rotate VPN right by FOV_X/2 degrees
1077         RotatePointAroundVector( frustum[0].normal, vup, vpn, -(90-r_refdef.fov_x / 2 ) );
1078         frustum[0].dist = DotProduct (r_origin, frustum[0].normal);
1079         PlaneClassify(&frustum[0]);
1080
1081         // rotate VPN left by FOV_X/2 degrees
1082         RotatePointAroundVector( frustum[1].normal, vup, vpn, 90-r_refdef.fov_x / 2 );
1083         frustum[1].dist = DotProduct (r_origin, frustum[1].normal);
1084         PlaneClassify(&frustum[1]);
1085
1086         // rotate VPN up by FOV_X/2 degrees
1087         RotatePointAroundVector( frustum[2].normal, vright, vpn, 90-r_refdef.fov_y / 2 );
1088         frustum[2].dist = DotProduct (r_origin, frustum[2].normal);
1089         PlaneClassify(&frustum[2]);
1090
1091         // rotate VPN down by FOV_X/2 degrees
1092         RotatePointAroundVector( frustum[3].normal, vright, vpn, -( 90 - r_refdef.fov_y / 2 ) );
1093         frustum[3].dist = DotProduct (r_origin, frustum[3].normal);
1094         PlaneClassify(&frustum[3]);
1095 }
1096
1097 /*
1098 ===============
1099 R_SetupFrame
1100 ===============
1101 */
1102 static void R_SetupFrame (void)
1103 {
1104 // don't allow cheats in multiplayer
1105         if (cl.maxclients > 1)
1106         {
1107                 if (r_fullbright.integer != 0)
1108                         Cvar_Set ("r_fullbright", "0");
1109                 if (r_ambient.value != 0)
1110                         Cvar_Set ("r_ambient", "0");
1111         }
1112
1113         r_framecount++;
1114
1115 // build the transformation matrix for the given view angles
1116         VectorCopy (r_refdef.vieworg, r_origin);
1117
1118         AngleVectors (r_refdef.viewangles, vpn, vright, vup);
1119
1120         R_AnimateLight ();
1121 }
1122
1123
1124 static void R_BlendView(void)
1125 {
1126         rmeshstate_t m;
1127         float r;
1128
1129         if (r_refdef.viewblend[3] < 0.01f)
1130                 return;
1131
1132         memset(&m, 0, sizeof(m));
1133         m.blendfunc1 = GL_SRC_ALPHA;
1134         m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
1135         m.depthdisable = true; // magic
1136         R_Mesh_Matrix(&r_identitymatrix);
1137         R_Mesh_State(&m);
1138
1139         R_Mesh_GetSpace(3);
1140         r = 64000;
1141         varray_vertex3f[0] = r_origin[0] + vpn[0] * 1.5 - vright[0] * r - vup[0] * r;
1142         varray_vertex3f[1] = r_origin[1] + vpn[1] * 1.5 - vright[1] * r - vup[1] * r;
1143         varray_vertex3f[2] = r_origin[2] + vpn[2] * 1.5 - vright[2] * r - vup[2] * r;
1144         varray_vertex3f[3] = r_origin[0] + vpn[0] * 1.5 - vright[0] * r + vup[0] * r * 3;
1145         varray_vertex3f[4] = r_origin[1] + vpn[1] * 1.5 - vright[1] * r + vup[1] * r * 3;
1146         varray_vertex3f[5] = r_origin[2] + vpn[2] * 1.5 - vright[2] * r + vup[2] * r * 3;
1147         varray_vertex3f[6] = r_origin[0] + vpn[0] * 1.5 + vright[0] * r * 3 - vup[0] * r;
1148         varray_vertex3f[7] = r_origin[1] + vpn[1] * 1.5 + vright[1] * r * 3 - vup[1] * r;
1149         varray_vertex3f[8] = r_origin[2] + vpn[2] * 1.5 + vright[2] * r * 3 - vup[2] * r;
1150         GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
1151         R_Mesh_Draw(3, 1, polygonelements);
1152 }
1153
1154 /*
1155 ================
1156 R_RenderView
1157
1158 r_refdef must be set before the first call
1159 ================
1160 */
1161 extern void R_DrawLightningBeams (void);
1162 void R_RenderView (void)
1163 {
1164         entity_render_t *world;
1165         if (!r_refdef.entities/* || !cl.worldmodel*/)
1166                 return; //Host_Error ("R_RenderView: NULL worldmodel");
1167
1168         if (r_shadow_realtime.integer == 1)
1169         {
1170 #if 0
1171                 if (!gl_texturecubemap)
1172                 {
1173                         Con_Printf("Cubemap texture support not detected, turning off r_shadow_realtime\n");
1174                         Cvar_SetValueQuick(&r_shadow_realtime, 0);
1175                 }
1176                 else if (!gl_dot3arb)
1177                 {
1178                         Con_Printf("Bumpmapping support not detected, turning off r_shadow_realtime\n");
1179                         Cvar_SetValueQuick(&r_shadow_realtime, 0);
1180                 }
1181                 else if (!gl_combine.integer)
1182                 {
1183                         Con_Printf("Combine disabled, please turn on gl_combine, turning off r_shadow_realtime\n");
1184                         Cvar_SetValueQuick(&r_shadow_realtime, 0);
1185                 }
1186                 else
1187 #endif
1188                 if (!gl_stencil)
1189                 {
1190                         Con_Printf("Stencil not enabled, turning off r_shadow_realtime, please type vid_stencil 1;vid_bitsperpixel 32;vid_restart and try again\n");
1191                         Cvar_SetValueQuick(&r_shadow_realtime, 0);
1192                 }
1193         }
1194
1195         R_Shadow_UpdateLightingMode();
1196
1197         world = &cl_entities[0].render;
1198
1199         // FIXME: move to client
1200         R_MoveExplosions();
1201         R_TimeReport("mexplosion");
1202
1203         R_Textures_Frame();
1204         R_SetupFrame();
1205         R_SetFrustum();
1206         R_SetupFog();
1207         R_SkyStartFrame();
1208         R_BuildLightList();
1209         R_TimeReport("setup");
1210
1211         R_WorldVisibility(world);
1212         R_TimeReport("worldvis");
1213
1214         R_FarClip_Start(r_origin, vpn, 768.0f);
1215         R_MarkEntities();
1216         r_farclip = R_FarClip_Finish() + 256.0f;
1217         R_TimeReport("markentity");
1218
1219         GL_SetupView_ViewPort(r_refdef.x, r_refdef.y, r_refdef.width, r_refdef.height);
1220         if (r_shadow_lightingmode > 0)
1221                 GL_SetupView_Mode_PerspectiveInfiniteFarClip(r_refdef.fov_x, r_refdef.fov_y, 1.0f);
1222         else
1223                 GL_SetupView_Mode_Perspective(r_refdef.fov_x, r_refdef.fov_y, 1.0f, r_farclip);
1224         GL_SetupView_Orientation_FromEntity (r_refdef.vieworg, r_refdef.viewangles);
1225         qglDepthFunc(GL_LEQUAL);
1226
1227         R_Mesh_Start();
1228         R_MeshQueue_BeginScene();
1229
1230         R_Shadow_UpdateWorldLightSelection();
1231
1232         if (R_DrawBrushModelsSky())
1233                 R_TimeReport("bmodelsky");
1234
1235         // must occur early because it can draw sky
1236         R_DrawWorld(world);
1237         R_TimeReport("world");
1238
1239         // don't let sound skip if going slow
1240         if (!intimerefresh && !r_speeds.integer)
1241                 S_ExtraUpdate ();
1242
1243         R_DrawModels(r_shadow_lightingmode > 0);
1244         R_TimeReport("models");
1245
1246         if (r_shadows.integer == 1 && r_shadow_lightingmode <= 0)
1247         {
1248                 R_DrawFakeShadows();
1249                 R_TimeReport("fakeshadow");
1250         }
1251
1252         if (r_shadow_lightingmode > 0)
1253         {
1254                 R_ShadowVolumeLighting(false);
1255                 R_TimeReport("dynlight");
1256         }
1257
1258         R_DrawLightningBeams();
1259         R_TimeReport("lightning");
1260
1261         R_DrawParticles();
1262         R_TimeReport("particles");
1263
1264         R_DrawExplosions();
1265         R_TimeReport("explosions");
1266
1267         R_MeshQueue_RenderTransparent();
1268         R_TimeReport("drawtrans");
1269
1270         R_DrawCoronas();
1271         R_TimeReport("coronas");
1272
1273         R_DrawWorldCrosshair();
1274         R_TimeReport("crosshair");
1275
1276         R_BlendView();
1277         R_TimeReport("blendview");
1278
1279         R_MeshQueue_Render();
1280         R_MeshQueue_EndScene();
1281         if (r_shadow_realtime.integer >= 2)
1282         {
1283                 R_ShadowVolumeLighting(true);
1284                 R_TimeReport("shadowvolume");
1285         }
1286         R_Mesh_Finish();
1287         R_TimeReport("meshfinish");
1288 }
1289
1290 /*
1291 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
1292 {
1293         int i;
1294         float *v, *c, f1, f2, diff[3];
1295         rmeshstate_t m;
1296         m.blendfunc1 = GL_SRC_ALPHA;
1297         m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
1298         R_Mesh_Matrix(&r_identitymatrix);
1299         R_Mesh_State(&m);
1300
1301         R_Mesh_GetSpace(8);
1302         varray_vertex[ 0] = mins[0];varray_vertex[ 1] = mins[1];varray_vertex[ 2] = mins[2];
1303         varray_vertex[ 4] = maxs[0];varray_vertex[ 5] = mins[1];varray_vertex[ 6] = mins[2];
1304         varray_vertex[ 8] = mins[0];varray_vertex[ 9] = maxs[1];varray_vertex[10] = mins[2];
1305         varray_vertex[12] = maxs[0];varray_vertex[13] = maxs[1];varray_vertex[14] = mins[2];
1306         varray_vertex[16] = mins[0];varray_vertex[17] = mins[1];varray_vertex[18] = maxs[2];
1307         varray_vertex[20] = maxs[0];varray_vertex[21] = mins[1];varray_vertex[22] = maxs[2];
1308         varray_vertex[24] = mins[0];varray_vertex[25] = maxs[1];varray_vertex[26] = maxs[2];
1309         varray_vertex[28] = maxs[0];varray_vertex[29] = maxs[1];varray_vertex[30] = maxs[2];
1310         R_FillColors(varray_color, 8, cr * r_colorscale, cg * r_colorscale, cb * r_colorscale, ca);
1311         if (fogenabled)
1312         {
1313                 for (i = 0, v = varray_vertex, c = varray_color;i < 8;i++, v += 4, c += 4)
1314                 {
1315                         VectorSubtract(v, r_origin, diff);
1316                         f2 = exp(fogdensity/DotProduct(diff, diff));
1317                         f1 = 1 - f2;
1318                         f2 *= r_colorscale;
1319                         c[0] = c[0] * f1 + fogcolor[0] * f2;
1320                         c[1] = c[1] * f1 + fogcolor[1] * f2;
1321                         c[2] = c[2] * f1 + fogcolor[2] * f2;
1322                 }
1323         }
1324         GL_UseColorArray();
1325         R_Mesh_Draw(8, 12);
1326 }
1327 */
1328
1329 int nomodelelements[24] =
1330 {
1331         5, 2, 0,
1332         5, 1, 2,
1333         5, 0, 3,
1334         5, 3, 1,
1335         0, 2, 4,
1336         2, 1, 4,
1337         3, 0, 4,
1338         1, 3, 4
1339 };
1340
1341 void R_DrawNoModelCallback(const void *calldata1, int calldata2)
1342 {
1343         const entity_render_t *ent = calldata1;
1344         int i;
1345         float f1, f2, *c, diff[3];
1346         rmeshstate_t m;
1347         memset(&m, 0, sizeof(m));
1348         if (ent->flags & EF_ADDITIVE)
1349         {
1350                 m.blendfunc1 = GL_SRC_ALPHA;
1351                 m.blendfunc2 = GL_ONE;
1352         }
1353         else if (ent->alpha < 1)
1354         {
1355                 m.blendfunc1 = GL_SRC_ALPHA;
1356                 m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
1357         }
1358         else
1359         {
1360                 m.blendfunc1 = GL_ONE;
1361                 m.blendfunc2 = GL_ZERO;
1362         }
1363         R_Mesh_Matrix(&ent->matrix);
1364         R_Mesh_State(&m);
1365
1366         GL_UseColorArray();
1367         R_Mesh_GetSpace(6);
1368         varray_vertex3f[ 0] = -16;varray_vertex3f[ 1] =   0;varray_vertex3f[ 2] =   0;
1369         varray_vertex3f[ 3] =  16;varray_vertex3f[ 4] =   0;varray_vertex3f[ 5] =   0;
1370         varray_vertex3f[ 6] =   0;varray_vertex3f[ 7] = -16;varray_vertex3f[ 8] =   0;
1371         varray_vertex3f[ 9] =   0;varray_vertex3f[10] =  16;varray_vertex3f[11] =   0;
1372         varray_vertex3f[12] =   0;varray_vertex3f[13] =   0;varray_vertex3f[14] = -16;
1373         varray_vertex3f[15] =   0;varray_vertex3f[16] =   0;varray_vertex3f[17] =  16;
1374         varray_color4f[ 0] = 0.00f * r_colorscale;varray_color4f[ 1] = 0.00f * r_colorscale;varray_color4f[ 2] = 0.50f * r_colorscale;varray_color4f[ 3] = ent->alpha;
1375         varray_color4f[ 4] = 0.00f * r_colorscale;varray_color4f[ 5] = 0.00f * r_colorscale;varray_color4f[ 6] = 0.50f * r_colorscale;varray_color4f[ 7] = ent->alpha;
1376         varray_color4f[ 8] = 0.00f * r_colorscale;varray_color4f[ 9] = 0.50f * r_colorscale;varray_color4f[10] = 0.00f * r_colorscale;varray_color4f[11] = ent->alpha;
1377         varray_color4f[12] = 0.00f * r_colorscale;varray_color4f[13] = 0.50f * r_colorscale;varray_color4f[14] = 0.00f * r_colorscale;varray_color4f[15] = ent->alpha;
1378         varray_color4f[16] = 0.50f * r_colorscale;varray_color4f[17] = 0.00f * r_colorscale;varray_color4f[18] = 0.00f * r_colorscale;varray_color4f[19] = ent->alpha;
1379         varray_color4f[20] = 0.50f * r_colorscale;varray_color4f[21] = 0.00f * r_colorscale;varray_color4f[22] = 0.00f * r_colorscale;varray_color4f[23] = ent->alpha;
1380         if (fogenabled)
1381         {
1382                 VectorSubtract(ent->origin, r_origin, diff);
1383                 f2 = exp(fogdensity/DotProduct(diff, diff));
1384                 f1 = 1 - f2;
1385                 for (i = 0, c = varray_color4f;i < 6;i++, c += 4)
1386                 {
1387                         c[0] = (c[0] * f1 + fogcolor[0] * f2) * r_colorscale;
1388                         c[1] = (c[1] * f1 + fogcolor[1] * f2) * r_colorscale;
1389                         c[2] = (c[2] * f1 + fogcolor[2] * f2) * r_colorscale;
1390                 }
1391         }
1392         else
1393         {
1394                 for (i = 0, c = varray_color4f;i < 6;i++, c += 4)
1395                 {
1396                         c[0] *= r_colorscale;
1397                         c[1] *= r_colorscale;
1398                         c[2] *= r_colorscale;
1399                 }
1400         }
1401         R_Mesh_Draw(6, 8, nomodelelements);
1402 }
1403
1404 void R_DrawNoModel(entity_render_t *ent)
1405 {
1406         //if ((ent->effects & EF_ADDITIVE) || (ent->alpha < 1))
1407                 R_MeshQueue_AddTransparent(ent->origin, R_DrawNoModelCallback, ent, 0);
1408         //else
1409         //      R_DrawNoModelCallback(ent, 0);
1410 }
1411
1412 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
1413 {
1414         vec3_t right1, right2, diff, normal;
1415
1416         VectorSubtract (org2, org1, normal);
1417         VectorNormalizeFast (normal);
1418
1419         // calculate 'right' vector for start
1420         VectorSubtract (r_origin, org1, diff);
1421         VectorNormalizeFast (diff);
1422         CrossProduct (normal, diff, right1);
1423
1424         // calculate 'right' vector for end
1425         VectorSubtract (r_origin, org2, diff);
1426         VectorNormalizeFast (diff);
1427         CrossProduct (normal, diff, right2);
1428
1429         vert[ 0] = org1[0] + width * right1[0];
1430         vert[ 1] = org1[1] + width * right1[1];
1431         vert[ 2] = org1[2] + width * right1[2];
1432         vert[ 3] = org1[0] - width * right1[0];
1433         vert[ 4] = org1[1] - width * right1[1];
1434         vert[ 5] = org1[2] - width * right1[2];
1435         vert[ 6] = org2[0] - width * right2[0];
1436         vert[ 7] = org2[1] - width * right2[1];
1437         vert[ 8] = org2[2] - width * right2[2];
1438         vert[ 9] = org2[0] + width * right2[0];
1439         vert[10] = org2[1] + width * right2[1];
1440         vert[11] = org2[2] + width * right2[2];
1441 }
1442
1443 void R_DrawSpriteMesh(const vec3_t origin, const vec3_t left, const vec3_t up, float scalex1, float scalex2, float scaley1, float scaley2)
1444 {
1445         R_Mesh_GetSpace(4);
1446         varray_texcoord2f[0][0] = 1;varray_texcoord2f[0][1] = 1;
1447         varray_texcoord2f[0][2] = 1;varray_texcoord2f[0][3] = 0;
1448         varray_texcoord2f[0][4] = 0;varray_texcoord2f[0][5] = 0;
1449         varray_texcoord2f[0][6] = 0;varray_texcoord2f[0][7] = 1;
1450         varray_vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
1451         varray_vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
1452         varray_vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
1453         varray_vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
1454         varray_vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
1455         varray_vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
1456         varray_vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
1457         varray_vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
1458         varray_vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
1459         varray_vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
1460         varray_vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
1461         varray_vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
1462         R_Mesh_Draw(4, 2, polygonelements);
1463 }
1464