fixed view location bugs in csqc; it was reading the player entity's render.origin...
[divverent/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 #include "polygon.h"
25
26 mempool_t *r_main_mempool;
27 rtexturepool_t *r_main_texturepool;
28
29 //
30 // screen size info
31 //
32 r_refdef_t r_refdef;
33 r_view_t r_view;
34 r_viewcache_t r_viewcache;
35
36 cvar_t r_nearclip = {0, "r_nearclip", "1", "distance from camera of nearclip plane" };
37 cvar_t r_showsurfaces = {0, "r_showsurfaces", "0", "shows surfaces as different colors"};
38 cvar_t r_showtris = {0, "r_showtris", "0", "shows triangle outlines, value controls brightness (can be above 1)"};
39 cvar_t r_shownormals = {0, "r_shownormals", "0", "shows per-vertex surface normals and tangent vectors for bumpmapped lighting"};
40 cvar_t r_showlighting = {0, "r_showlighting", "0", "shows areas lit by lights, useful for finding out why some areas of a map render slowly (bright orange = lots of passes = slow), a value of 2 disables depth testing which can be interesting but not very useful"};
41 cvar_t r_showshadowvolumes = {0, "r_showshadowvolumes", "0", "shows areas shadowed by lights, useful for finding out why some areas of a map render slowly (bright blue = lots of passes = slow), a value of 2 disables depth testing which can be interesting but not very useful"};
42 cvar_t r_showcollisionbrushes = {0, "r_showcollisionbrushes", "0", "draws collision brushes in quake3 maps (mode 1), mode 2 disables rendering of world (trippy!)"};
43 cvar_t r_showcollisionbrushes_polygonfactor = {0, "r_showcollisionbrushes_polygonfactor", "-1", "expands outward the brush polygons a little bit, used to make collision brushes appear infront of walls"};
44 cvar_t r_showcollisionbrushes_polygonoffset = {0, "r_showcollisionbrushes_polygonoffset", "0", "nudges brush polygon depth in hardware depth units, used to make collision brushes appear infront of walls"};
45 cvar_t r_showdisabledepthtest = {0, "r_showdisabledepthtest", "0", "disables depth testing on r_show* cvars, allowing you to see what hidden geometry the graphics card is processing"};
46 cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating polygons) in world interior in quake1 maps"};
47 cvar_t r_drawentities = {0, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"};
48 cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1", "draw your weapon model"};
49 cvar_t r_speeds = {0, "r_speeds","0", "displays rendering statistics and per-subsystem timings"};
50 cvar_t r_fullbright = {0, "r_fullbright","0", "make everything bright cheat (not allowed in multiplayer)"};
51 cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1", "opacity of water polygons"};
52 cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1", "enables dynamic lights (rocket glow and such)"};
53 cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1", "enables glowing pixels in quake textures (changes need r_restart to take effect)"};
54 cvar_t r_q1bsp_skymasking = {0, "r_qb1sp_skymasking", "1", "allows sky polygons in quake1 maps to obscure other geometry"};
55
56 cvar_t gl_fogenable = {0, "gl_fogenable", "0", "nehahra fog enable (for Nehahra compatibility only)"};
57 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25", "nehahra fog density (recommend values below 0.1) (for Nehahra compatibility only)"};
58 cvar_t gl_fogred = {0, "gl_fogred","0.3", "nehahra fog color red value (for Nehahra compatibility only)"};
59 cvar_t gl_foggreen = {0, "gl_foggreen","0.3", "nehahra fog color green value (for Nehahra compatibility only)"};
60 cvar_t gl_fogblue = {0, "gl_fogblue","0.3", "nehahra fog color blue value (for Nehahra compatibility only)"};
61 cvar_t gl_fogstart = {0, "gl_fogstart", "0", "nehahra fog start distance (for Nehahra compatibility only)"};
62 cvar_t gl_fogend = {0, "gl_fogend","0", "nehahra fog end distance (for Nehahra compatibility only)"};
63
64 cvar_t r_textureunits = {0, "r_textureunits", "32", "number of hardware texture units reported by driver (note: setting this to 1 turns off gl_combine)"};
65
66 cvar_t r_glsl = {0, "r_glsl", "1", "enables use of OpenGL 2.0 pixel shaders for lighting"};
67 cvar_t r_glsl_offsetmapping = {0, "r_glsl_offsetmapping", "0", "offset mapping effect (also known as parallax mapping or virtual displacement mapping)"};
68 cvar_t r_glsl_offsetmapping_reliefmapping = {0, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"};
69 cvar_t r_glsl_offsetmapping_scale = {0, "r_glsl_offsetmapping_scale", "0.04", "how deep the offset mapping effect is"};
70 cvar_t r_glsl_deluxemapping = {0, "r_glsl_deluxemapping", "1", "use per pixel lighting on deluxemap-compiled q3bsp maps (or a value of 2 forces deluxemap shading even without deluxemaps)"};
71
72 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "1", "enables animation smoothing on sprites (requires r_lerpmodels 1)"};
73 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"};
74 cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1", "makes water scroll around, value controls how much"};
75
76 cvar_t r_bloom = {CVAR_SAVE, "r_bloom", "0", "enables bloom effect (makes bright pixels affect neighboring pixels)"};
77 cvar_t r_bloom_intensity = {CVAR_SAVE, "r_bloom_intensity", "1.5", "how bright the glow is"};
78 cvar_t r_bloom_blur = {CVAR_SAVE, "r_bloom_blur", "4", "how large the glow is"};
79 cvar_t r_bloom_resolution = {CVAR_SAVE, "r_bloom_resolution", "320", "what resolution to perform the bloom effect at (independent of screen resolution)"};
80 cvar_t r_bloom_power = {CVAR_SAVE, "r_bloom_power", "2", "how much to darken the image before blurring to make the bloom effect"};
81
82 cvar_t r_hdr = {CVAR_SAVE, "r_hdr", "0", "enables High Dynamic Range bloom effect (higher quality version of r_bloom)"};
83 cvar_t r_hdr_scenebrightness = {CVAR_SAVE, "r_hdr_scenebrightness", "1", "global rendering brightness"};
84 cvar_t r_hdr_bloomintensity = {CVAR_SAVE, "r_hdr_bloomintensity", "0.5", "amount of bloom"};
85 cvar_t r_hdr_glowintensity = {CVAR_SAVE, "r_hdr_glowintensity", "1", "how bright light emitting textures should appear"};
86
87 cvar_t r_smoothnormals_areaweighting = {0, "r_smoothnormals_areaweighting", "1", "uses significantly faster (and supposedly higher quality) area-weighted vertex normals and tangent vectors rather than summing normalized triangle normals and tangents"};
88
89 cvar_t developer_texturelogging = {0, "developer_texturelogging", "0", "produces a textures.log file containing names of skins and map textures the engine tried to load"};
90
91 cvar_t gl_lightmaps = {0, "gl_lightmaps", "0", "draws only lightmaps, no texture (for level designers)"};
92
93 cvar_t r_test = {0, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"}; // used for testing renderer code changes, otherwise does nothing
94 cvar_t r_batchmode = {0, "r_batchmode", "1", "selects method of rendering multiple surfaces with one driver call (values are 0, 1, 2, etc...)"};
95
96 rtexture_t *r_bloom_texture_screen;
97 rtexture_t *r_bloom_texture_bloom;
98 rtexture_t *r_texture_blanknormalmap;
99 rtexture_t *r_texture_white;
100 rtexture_t *r_texture_black;
101 rtexture_t *r_texture_notexture;
102 rtexture_t *r_texture_whitecube;
103 rtexture_t *r_texture_normalizationcube;
104 rtexture_t *r_texture_fogattenuation;
105 //rtexture_t *r_texture_fogintensity;
106
107 // information about each possible shader permutation
108 r_glsl_permutation_t r_glsl_permutations[SHADERPERMUTATION_COUNT];
109 // currently selected permutation
110 r_glsl_permutation_t *r_glsl_permutation;
111
112 // temporary variable used by a macro
113 int fogtableindex;
114
115 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
116 {
117         int i;
118         for (i = 0;i < verts;i++)
119         {
120                 out[0] = in[0] * r;
121                 out[1] = in[1] * g;
122                 out[2] = in[2] * b;
123                 out[3] = in[3];
124                 in += 4;
125                 out += 4;
126         }
127 }
128
129 void R_FillColors(float *out, int verts, float r, float g, float b, float a)
130 {
131         int i;
132         for (i = 0;i < verts;i++)
133         {
134                 out[0] = r;
135                 out[1] = g;
136                 out[2] = b;
137                 out[3] = a;
138                 out += 4;
139         }
140 }
141
142 // FIXME: move this to client?
143 void FOG_clear(void)
144 {
145         if (gamemode == GAME_NEHAHRA)
146         {
147                 Cvar_Set("gl_fogenable", "0");
148                 Cvar_Set("gl_fogdensity", "0.2");
149                 Cvar_Set("gl_fogred", "0.3");
150                 Cvar_Set("gl_foggreen", "0.3");
151                 Cvar_Set("gl_fogblue", "0.3");
152         }
153         r_refdef.fog_density = r_refdef.fog_red = r_refdef.fog_green = r_refdef.fog_blue = 0.0f;
154 }
155
156 // FIXME: move this to client?
157 void FOG_registercvars(void)
158 {
159         int x;
160         double r, alpha;
161
162         if (gamemode == GAME_NEHAHRA)
163         {
164                 Cvar_RegisterVariable (&gl_fogenable);
165                 Cvar_RegisterVariable (&gl_fogdensity);
166                 Cvar_RegisterVariable (&gl_fogred);
167                 Cvar_RegisterVariable (&gl_foggreen);
168                 Cvar_RegisterVariable (&gl_fogblue);
169                 Cvar_RegisterVariable (&gl_fogstart);
170                 Cvar_RegisterVariable (&gl_fogend);
171         }
172
173         r = (-1.0/256.0) * (FOGTABLEWIDTH * FOGTABLEWIDTH);
174         for (x = 0;x < FOGTABLEWIDTH;x++)
175         {
176                 alpha = exp(r / ((double)x*(double)x));
177                 if (x == FOGTABLEWIDTH - 1)
178                         alpha = 1;
179                 r_refdef.fogtable[x] = bound(0, alpha, 1);
180         }
181 }
182
183 static void R_BuildBlankTextures(void)
184 {
185         unsigned char data[4];
186         data[0] = 128; // normal X
187         data[1] = 128; // normal Y
188         data[2] = 255; // normal Z
189         data[3] = 128; // height
190         r_texture_blanknormalmap = R_LoadTexture2D(r_main_texturepool, "blankbump", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
191         data[0] = 255;
192         data[1] = 255;
193         data[2] = 255;
194         data[3] = 255;
195         r_texture_white = R_LoadTexture2D(r_main_texturepool, "blankwhite", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
196         data[0] = 0;
197         data[1] = 0;
198         data[2] = 0;
199         data[3] = 255;
200         r_texture_black = R_LoadTexture2D(r_main_texturepool, "blankblack", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
201 }
202
203 static void R_BuildNoTexture(void)
204 {
205         int x, y;
206         unsigned char pix[16][16][4];
207         // this makes a light grey/dark grey checkerboard texture
208         for (y = 0;y < 16;y++)
209         {
210                 for (x = 0;x < 16;x++)
211                 {
212                         if ((y < 8) ^ (x < 8))
213                         {
214                                 pix[y][x][0] = 128;
215                                 pix[y][x][1] = 128;
216                                 pix[y][x][2] = 128;
217                                 pix[y][x][3] = 255;
218                         }
219                         else
220                         {
221                                 pix[y][x][0] = 64;
222                                 pix[y][x][1] = 64;
223                                 pix[y][x][2] = 64;
224                                 pix[y][x][3] = 255;
225                         }
226                 }
227         }
228         r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_RGBA, TEXF_MIPMAP, NULL);
229 }
230
231 static void R_BuildWhiteCube(void)
232 {
233         unsigned char data[6*1*1*4];
234         data[ 0] = 255;data[ 1] = 255;data[ 2] = 255;data[ 3] = 255;
235         data[ 4] = 255;data[ 5] = 255;data[ 6] = 255;data[ 7] = 255;
236         data[ 8] = 255;data[ 9] = 255;data[10] = 255;data[11] = 255;
237         data[12] = 255;data[13] = 255;data[14] = 255;data[15] = 255;
238         data[16] = 255;data[17] = 255;data[18] = 255;data[19] = 255;
239         data[20] = 255;data[21] = 255;data[22] = 255;data[23] = 255;
240         r_texture_whitecube = R_LoadTextureCubeMap(r_main_texturepool, "whitecube", 1, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL);
241 }
242
243 static void R_BuildNormalizationCube(void)
244 {
245         int x, y, side;
246         vec3_t v;
247         vec_t s, t, intensity;
248 #define NORMSIZE 64
249         unsigned char data[6][NORMSIZE][NORMSIZE][4];
250         for (side = 0;side < 6;side++)
251         {
252                 for (y = 0;y < NORMSIZE;y++)
253                 {
254                         for (x = 0;x < NORMSIZE;x++)
255                         {
256                                 s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
257                                 t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
258                                 switch(side)
259                                 {
260                                 default:
261                                 case 0:
262                                         v[0] = 1;
263                                         v[1] = -t;
264                                         v[2] = -s;
265                                         break;
266                                 case 1:
267                                         v[0] = -1;
268                                         v[1] = -t;
269                                         v[2] = s;
270                                         break;
271                                 case 2:
272                                         v[0] = s;
273                                         v[1] = 1;
274                                         v[2] = t;
275                                         break;
276                                 case 3:
277                                         v[0] = s;
278                                         v[1] = -1;
279                                         v[2] = -t;
280                                         break;
281                                 case 4:
282                                         v[0] = s;
283                                         v[1] = -t;
284                                         v[2] = 1;
285                                         break;
286                                 case 5:
287                                         v[0] = -s;
288                                         v[1] = -t;
289                                         v[2] = -1;
290                                         break;
291                                 }
292                                 intensity = 127.0f / sqrt(DotProduct(v, v));
293                                 data[side][y][x][0] = (unsigned char)(128.0f + intensity * v[0]);
294                                 data[side][y][x][1] = (unsigned char)(128.0f + intensity * v[1]);
295                                 data[side][y][x][2] = (unsigned char)(128.0f + intensity * v[2]);
296                                 data[side][y][x][3] = 255;
297                         }
298                 }
299         }
300         r_texture_normalizationcube = R_LoadTextureCubeMap(r_main_texturepool, "normalcube", NORMSIZE, &data[0][0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL);
301 }
302
303 static void R_BuildFogTexture(void)
304 {
305         int x, b;
306         double r, alpha;
307 #define FOGWIDTH 64
308         unsigned char data1[FOGWIDTH][4];
309         //unsigned char data2[FOGWIDTH][4];
310         r = (-1.0/256.0) * (FOGWIDTH * FOGWIDTH);
311         for (x = 0;x < FOGWIDTH;x++)
312         {
313                 alpha = exp(r / ((double)x*(double)x));
314                 if (x == FOGWIDTH - 1)
315                         alpha = 1;
316                 b = (int)(256.0 * alpha);
317                 b = bound(0, b, 255);
318                 data1[x][0] = 255 - b;
319                 data1[x][1] = 255 - b;
320                 data1[x][2] = 255 - b;
321                 data1[x][3] = 255;
322                 //data2[x][0] = b;
323                 //data2[x][1] = b;
324                 //data2[x][2] = b;
325                 //data2[x][3] = 255;
326         }
327         r_texture_fogattenuation = R_LoadTexture2D(r_main_texturepool, "fogattenuation", FOGWIDTH, 1, &data1[0][0], TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_FORCELINEAR | TEXF_CLAMP, NULL);
328         //r_texture_fogintensity = R_LoadTexture2D(r_main_texturepool, "fogintensity", FOGWIDTH, 1, &data2[0][0], TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_FORCELINEAR | TEXF_CLAMP, NULL);
329 }
330
331 static const char *builtinshaderstring =
332 "// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
333 "// written by Forest 'LordHavoc' Hale\n"
334 "\n"
335 "// common definitions between vertex shader and fragment shader:\n"
336 "\n"
337 "#ifdef __GLSL_CG_DATA_TYPES\n"
338 "#define myhalf half\n"
339 "#define myhvec2 hvec2\n"
340 "#define myhvec3 hvec3\n"
341 "#define myhvec4 hvec4\n"
342 "#else\n"
343 "#define myhalf float\n"
344 "#define myhvec2 vec2\n"
345 "#define myhvec3 vec3\n"
346 "#define myhvec4 vec4\n"
347 "#endif\n"
348 "\n"
349 "varying vec2 TexCoord;\n"
350 "varying vec2 TexCoordLightmap;\n"
351 "\n"
352 "varying vec3 CubeVector;\n"
353 "varying vec3 LightVector;\n"
354 "varying vec3 EyeVector;\n"
355 "#ifdef USEFOG\n"
356 "varying vec3 EyeVectorModelSpace;\n"
357 "#endif\n"
358 "\n"
359 "varying vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n"
360 "varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
361 "varying vec3 VectorR; // direction of R texcoord (surface normal)\n"
362 "\n"
363 "\n"
364 "\n"
365 "\n"
366 "// vertex shader specific:\n"
367 "#ifdef VERTEX_SHADER\n"
368 "\n"
369 "uniform vec3 LightPosition;\n"
370 "uniform vec3 EyePosition;\n"
371 "uniform vec3 LightDir;\n"
372 "\n"
373 "// TODO: get rid of tangentt (texcoord2) and use a crossproduct to regenerate it from tangents (texcoord1) and normal (texcoord3)\n"
374 "\n"
375 "void main(void)\n"
376 "{\n"
377 "       gl_FrontColor = gl_Color;\n"
378 "       // copy the surface texcoord\n"
379 "       TexCoord = vec2(gl_TextureMatrix[0] * gl_MultiTexCoord0);\n"
380 "#if !defined(MODE_LIGHTSOURCE) && !defined(MODE_LIGHTDIRECTION)\n"
381 "       TexCoordLightmap = vec2(gl_MultiTexCoord4);\n"
382 "#endif\n"
383 "\n"
384 "#ifdef MODE_LIGHTSOURCE\n"
385 "       // transform vertex position into light attenuation/cubemap space\n"
386 "       // (-1 to +1 across the light box)\n"
387 "       CubeVector = vec3(gl_TextureMatrix[3] * gl_Vertex);\n"
388 "\n"
389 "       // transform unnormalized light direction into tangent space\n"
390 "       // (we use unnormalized to ensure that it interpolates correctly and then\n"
391 "       //  normalize it per pixel)\n"
392 "       vec3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
393 "       LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
394 "       LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
395 "       LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
396 "#endif\n"
397 "\n"
398 "#ifdef MODE_LIGHTDIRECTION\n"
399 "       LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);\n"
400 "       LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);\n"
401 "       LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);\n"
402 "#endif\n"
403 "\n"
404 "       // transform unnormalized eye direction into tangent space\n"
405 "#ifndef USEFOG\n"
406 "       vec3 EyeVectorModelSpace;\n"
407 "#endif\n"
408 "       EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
409 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
410 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
411 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
412 "\n"
413 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
414 "       VectorS = gl_MultiTexCoord1.xyz;\n"
415 "       VectorT = gl_MultiTexCoord2.xyz;\n"
416 "       VectorR = gl_MultiTexCoord3.xyz;\n"
417 "#endif\n"
418 "\n"
419 "       // transform vertex to camera space, using ftransform to match non-VS\n"
420 "       // rendering\n"
421 "       gl_Position = ftransform();\n"
422 "}\n"
423 "\n"
424 "#endif // VERTEX_SHADER\n"
425 "\n"
426 "\n"
427 "\n"
428 "\n"
429 "// fragment shader specific:\n"
430 "#ifdef FRAGMENT_SHADER\n"
431 "\n"
432 "uniform sampler2D Texture_Normal;\n"
433 "uniform sampler2D Texture_Color;\n"
434 "uniform sampler2D Texture_Gloss;\n"
435 "uniform samplerCube Texture_Cube;\n"
436 "uniform sampler2D Texture_FogMask;\n"
437 "uniform sampler2D Texture_Pants;\n"
438 "uniform sampler2D Texture_Shirt;\n"
439 "uniform sampler2D Texture_Lightmap;\n"
440 "uniform sampler2D Texture_Deluxemap;\n"
441 "uniform sampler2D Texture_Glow;\n"
442 "\n"
443 "uniform myhvec3 LightColor;\n"
444 "uniform myhvec3 AmbientColor;\n"
445 "uniform myhvec3 DiffuseColor;\n"
446 "uniform myhvec3 SpecularColor;\n"
447 "uniform myhvec3 Color_Pants;\n"
448 "uniform myhvec3 Color_Shirt;\n"
449 "uniform myhvec3 FogColor;\n"
450 "\n"
451 "uniform myhalf GlowScale;\n"
452 "uniform myhalf SceneBrightness;\n"
453 "\n"
454 "uniform float OffsetMapping_Scale;\n"
455 "uniform float OffsetMapping_Bias;\n"
456 "uniform float FogRangeRecip;\n"
457 "\n"
458 "uniform myhalf AmbientScale;\n"
459 "uniform myhalf DiffuseScale;\n"
460 "uniform myhalf SpecularScale;\n"
461 "uniform myhalf SpecularPower;\n"
462 "\n"
463 "void main(void)\n"
464 "{\n"
465 "       // apply offsetmapping\n"
466 "#ifdef USEOFFSETMAPPING\n"
467 "       vec2 TexCoordOffset = TexCoord;\n"
468 "#define TexCoord TexCoordOffset\n"
469 "\n"
470 "       vec3 eyedir = vec3(normalize(EyeVector));\n"
471 "       float depthbias = 1.0 - eyedir.z; // should this be a -?\n"
472 "       depthbias = 1.0 - depthbias * depthbias;\n"
473 "\n"
474 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
475 "       // 14 sample relief mapping: linear search and then binary search\n"
476 "       //vec3 OffsetVector = vec3(EyeVector.xy * (1.0 / EyeVector.z) * depthbias * OffsetMapping_Scale * vec2(-0.1, 0.1), -0.1);\n"
477 "       //vec3 OffsetVector = vec3(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-0.1, 0.1), -0.1);\n"
478 "       vec3 OffsetVector = vec3(eyedir.xy * OffsetMapping_Scale * vec2(-0.1, 0.1), -0.1);\n"
479 "       vec3 RT = vec3(TexCoord - OffsetVector.xy * 10.0, 1.0) + OffsetVector;\n"
480 "       if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;\n"
481 "       if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;\n"
482 "       if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;\n"
483 "       if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;\n"
484 "       if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;\n"
485 "       if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;\n"
486 "       if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;\n"
487 "       if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;\n"
488 "       if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;OffsetVector *= 0.5;RT -= OffsetVector;\n"
489 "       if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;OffsetVector *= 0.5;RT -= OffsetVector;\n"
490 "       if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;OffsetVector *= 0.5;RT -= OffsetVector;\n"
491 "       if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;OffsetVector *= 0.5;RT -= OffsetVector;\n"
492 "       if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;OffsetVector *= 0.5;RT -= OffsetVector;\n"
493 "       if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;OffsetVector *= 0.5;RT -= OffsetVector;\n"
494 "       TexCoord = RT.xy;\n"
495 "#elif 1\n"
496 "       // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
497 "       //vec2 OffsetVector = vec2(EyeVector.xy * (1.0 / EyeVector.z) * depthbias) * OffsetMapping_Scale * vec2(-0.333, 0.333);\n"
498 "       //vec2 OffsetVector = vec2(normalize(EyeVector.xy)) * OffsetMapping_Scale * vec2(-0.333, 0.333);\n"
499 "       vec2 OffsetVector = vec2(eyedir.xy) * OffsetMapping_Scale * vec2(-0.333, 0.333);\n"
500 "       //TexCoord += OffsetVector * 3.0;\n"
501 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
502 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
503 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
504 "#elif 0\n"
505 "       // 10 sample offset mapping\n"
506 "       //vec2 OffsetVector = vec2(EyeVector.xy * (1.0 / EyeVector.z) * depthbias) * OffsetMapping_Scale * vec2(-0.333, 0.333);\n"
507 "       //vec2 OffsetVector = vec2(normalize(EyeVector.xy)) * OffsetMapping_Scale * vec2(-0.333, 0.333);\n"
508 "       vec2 OffsetVector = vec2(eyedir.xy) * OffsetMapping_Scale * vec2(-0.1, 0.1);\n"
509 "       //TexCoord += OffsetVector * 3.0;\n"
510 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
511 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
512 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
513 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
514 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
515 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
516 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
517 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
518 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
519 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
520 "#elif 1\n"
521 "       // parallax mapping as described in the paper\n"
522 "       // 'Parallax Mapping with Offset Limiting: A Per-Pixel Approximation of Uneven Surfaces' by Terry Welsh\n"
523 "       // The paper provides code in the ARB fragment program assembly language\n"
524 "       // I translated it to GLSL but may have done something wrong - SavageX\n"
525 "       // LordHavoc: removed bias and simplified to one line\n"
526 "       // LordHavoc: this is just a single sample offsetmapping...\n"
527 "       TexCoordOffset += vec2(eyedir.x, -1.0 * eyedir.y) * OffsetMapping_Scale * texture2D(Texture_Normal, TexCoord).a;\n"
528 "#else\n"
529 "       // parallax mapping as described in the paper\n"
530 "       // 'Parallax Mapping with Offset Limiting: A Per-Pixel Approximation of Uneven Surfaces' by Terry Welsh\n"
531 "       // The paper provides code in the ARB fragment program assembly language\n"
532 "       // I translated it to GLSL but may have done something wrong - SavageX\n"
533 "       float height = texture2D(Texture_Normal, TexCoord).a;\n"
534 "       height = (height - 0.5) * OffsetMapping_Scale; // bias and scale\n"
535 "       TexCoordOffset += height * vec2(eyedir.x, -1.0 * eyedir.y);\n"
536 "#endif\n"
537 "#endif\n"
538 "\n"
539 "       // combine the diffuse textures (base, pants, shirt)\n"
540 "       myhvec4 color = myhvec4(texture2D(Texture_Color, TexCoord));\n"
541 "#ifdef USECOLORMAPPING\n"
542 "       color.rgb += myhvec3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + myhvec3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
543 "#endif\n"
544 "\n"
545 "\n"
546 "\n"
547 "\n"
548 "#ifdef MODE_LIGHTSOURCE\n"
549 "       // light source\n"
550 "\n"
551 "       // get the surface normal and light normal\n"
552 "       myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
553 "       myhvec3 diffusenormal = myhvec3(normalize(LightVector));\n"
554 "\n"
555 "       // calculate directional shading\n"
556 "       color.rgb *= AmbientScale + DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
557 "#ifdef USESPECULAR\n"
558 "       myhvec3 specularnormal = normalize(diffusenormal + myhvec3(normalize(EyeVector)));\n"
559 "       color.rgb += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
560 "#endif\n"
561 "\n"
562 "#ifdef USECUBEFILTER\n"
563 "       // apply light cubemap filter\n"
564 "       //color.rgb *= normalize(CubeVector) * 0.5 + 0.5;//vec3(textureCube(Texture_Cube, CubeVector));\n"
565 "       color.rgb *= myhvec3(textureCube(Texture_Cube, CubeVector));\n"
566 "#endif\n"
567 "\n"
568 "       // apply light color\n"
569 "       color.rgb *= LightColor;\n"
570 "\n"
571 "       // apply attenuation\n"
572 "       //\n"
573 "       // the attenuation is (1-(x*x+y*y+z*z)) which gives a large bright\n"
574 "       // center and sharp falloff at the edge, this is about the most efficient\n"
575 "       // we can get away with as far as providing illumination.\n"
576 "       //\n"
577 "       // pow(1-(x*x+y*y+z*z), 4) is far more realistic but needs large lights to\n"
578 "       // provide significant illumination, large = slow = pain.\n"
579 "       color.rgb *= myhalf(max(1.0 - dot(CubeVector, CubeVector), 0.0));\n"
580 "\n"
581 "\n"
582 "\n"
583 "\n"
584 "#elif defined(MODE_LIGHTDIRECTION)\n"
585 "       // directional model lighting\n"
586 "\n"
587 "       // get the surface normal and light normal\n"
588 "       myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
589 "       myhvec3 diffusenormal = myhvec3(normalize(LightVector));\n"
590 "\n"
591 "       // calculate directional shading\n"
592 "       color.rgb *= AmbientColor + DiffuseColor * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
593 "#ifdef USESPECULAR\n"
594 "       myhvec3 specularnormal = normalize(diffusenormal + myhvec3(normalize(EyeVector)));\n"
595 "       color.rgb += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularColor * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
596 "#endif\n"
597 "\n"
598 "\n"
599 "\n"
600 "\n"
601 "#elif defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
602 "       // deluxemap lightmapping using light vectors in modelspace (evil q3map2)\n"
603 "\n"
604 "       // get the surface normal and light normal\n"
605 "       myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
606 "\n"
607 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
608 "       myhvec3 diffusenormal_modelspace = myhvec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - myhvec3(0.5);\n"
609 "       myhvec3 diffusenormal = normalize(myhvec3(dot(diffusenormal_modelspace, myhvec3(VectorS)), dot(diffusenormal_modelspace, myhvec3(VectorT)), dot(diffusenormal_modelspace, myhvec3(VectorR))));\n"
610 "#else\n"
611 "       myhvec3 diffusenormal = normalize(myhvec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - myhvec3(0.5));\n"
612 "#endif\n"
613 "       // calculate directional shading\n"
614 "       myhvec3 tempcolor = color.rgb * (DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0)));\n"
615 "#ifdef USESPECULAR\n"
616 "       myhvec3 specularnormal = myhvec3(normalize(diffusenormal + myhvec3(normalize(EyeVector))));\n"
617 "       tempcolor += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
618 "#endif\n"
619 "\n"
620 "       // apply lightmap color\n"
621 "       color.rgb = tempcolor * myhvec3(texture2D(Texture_Lightmap, TexCoordLightmap)) + color.rgb * AmbientScale;\n"
622 "\n"
623 "\n"
624 "#else // MODE none (lightmap)\n"
625 "       // apply lightmap color\n"
626 "       color.rgb *= myhvec3(texture2D(Texture_Lightmap, TexCoordLightmap)) * DiffuseScale + myhvec3(AmbientScale);\n"
627 "#endif // MODE\n"
628 "\n"
629 "       color *= myhvec4(gl_Color);\n"
630 "\n"
631 "#ifdef USEGLOW\n"
632 "       color.rgb += myhvec3(texture2D(Texture_Glow, TexCoord)) * GlowScale;\n"
633 "#endif\n"
634 "\n"
635 "#ifdef USEFOG\n"
636 "       // apply fog\n"
637 "       myhalf fog = myhalf(texture2D(Texture_FogMask, myhvec2(length(EyeVectorModelSpace)*FogRangeRecip, 0.0)).x);\n"
638 "       color.rgb = color.rgb * fog + FogColor * (1.0 - fog);\n"
639 "#endif\n"
640 "\n"
641 "       color.rgb *= SceneBrightness;\n"
642 "\n"
643 "       gl_FragColor = vec4(color);\n"
644 "}\n"
645 "\n"
646 "#endif // FRAGMENT_SHADER\n"
647 ;
648
649 // NOTE: MUST MATCH ORDER OF SHADERPERMUTATION_* DEFINES!
650 const char *permutationinfo[][2] =
651 {
652         {"#define MODE_LIGHTSOURCE\n", " lightsource"},
653         {"#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
654         {"#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
655         {"#define MODE_LIGHTDIRECTION\n", " lightdirection"},
656         {"#define USEGLOW\n", " glow"},
657         {"#define USEFOG\n", " fog"},
658         {"#define USECOLORMAPPING\n", " colormapping"},
659         {"#define USESPECULAR\n", " specular"},
660         {"#define USECUBEFILTER\n", " cubefilter"},
661         {"#define USEOFFSETMAPPING\n", " offsetmapping"},
662         {"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"},
663         {NULL, NULL}
664 };
665
666 void R_GLSL_CompilePermutation(int permutation)
667 {
668         int i;
669         r_glsl_permutation_t *p = r_glsl_permutations + permutation;
670         int vertstrings_count;
671         int fragstrings_count;
672         char *shaderstring;
673         const char *vertstrings_list[SHADERPERMUTATION_COUNT+1];
674         const char *fragstrings_list[SHADERPERMUTATION_COUNT+1];
675         char permutationname[256];
676         if (p->compiled)
677                 return;
678         p->compiled = true;
679         vertstrings_list[0] = "#define VERTEX_SHADER\n";
680         fragstrings_list[0] = "#define FRAGMENT_SHADER\n";
681         vertstrings_count = 1;
682         fragstrings_count = 1;
683         permutationname[0] = 0;
684         for (i = 0;permutationinfo[i][0];i++)
685         {
686                 if (permutation & (1<<i))
687                 {
688                         vertstrings_list[vertstrings_count++] = permutationinfo[i][0];
689                         fragstrings_list[fragstrings_count++] = permutationinfo[i][0];
690                         strlcat(permutationname, permutationinfo[i][1], sizeof(permutationname));
691                 }
692                 else
693                 {
694                         // keep line numbers correct
695                         vertstrings_list[vertstrings_count++] = "\n";
696                         fragstrings_list[fragstrings_count++] = "\n";
697                 }
698         }
699         shaderstring = (char *)FS_LoadFile("glsl/default.glsl", r_main_mempool, false, NULL);
700         if (shaderstring)
701         {
702                 Con_DPrintf("GLSL shader text loaded from disk\n");
703                 vertstrings_list[vertstrings_count++] = shaderstring;
704                 fragstrings_list[fragstrings_count++] = shaderstring;
705         }
706         else
707         {
708                 vertstrings_list[vertstrings_count++] = builtinshaderstring;
709                 fragstrings_list[fragstrings_count++] = builtinshaderstring;
710         }
711         p->program = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, fragstrings_count, fragstrings_list);
712         if (p->program)
713         {
714                 CHECKGLERROR
715                 qglUseProgramObjectARB(p->program);CHECKGLERROR
716                 p->loc_Texture_Normal      = qglGetUniformLocationARB(p->program, "Texture_Normal");
717                 p->loc_Texture_Color       = qglGetUniformLocationARB(p->program, "Texture_Color");
718                 p->loc_Texture_Gloss       = qglGetUniformLocationARB(p->program, "Texture_Gloss");
719                 p->loc_Texture_Cube        = qglGetUniformLocationARB(p->program, "Texture_Cube");
720                 p->loc_Texture_FogMask     = qglGetUniformLocationARB(p->program, "Texture_FogMask");
721                 p->loc_Texture_Pants       = qglGetUniformLocationARB(p->program, "Texture_Pants");
722                 p->loc_Texture_Shirt       = qglGetUniformLocationARB(p->program, "Texture_Shirt");
723                 p->loc_Texture_Lightmap    = qglGetUniformLocationARB(p->program, "Texture_Lightmap");
724                 p->loc_Texture_Deluxemap   = qglGetUniformLocationARB(p->program, "Texture_Deluxemap");
725                 p->loc_Texture_Glow        = qglGetUniformLocationARB(p->program, "Texture_Glow");
726                 p->loc_FogColor            = qglGetUniformLocationARB(p->program, "FogColor");
727                 p->loc_LightPosition       = qglGetUniformLocationARB(p->program, "LightPosition");
728                 p->loc_EyePosition         = qglGetUniformLocationARB(p->program, "EyePosition");
729                 p->loc_LightColor          = qglGetUniformLocationARB(p->program, "LightColor");
730                 p->loc_Color_Pants         = qglGetUniformLocationARB(p->program, "Color_Pants");
731                 p->loc_Color_Shirt         = qglGetUniformLocationARB(p->program, "Color_Shirt");
732                 p->loc_FogRangeRecip       = qglGetUniformLocationARB(p->program, "FogRangeRecip");
733                 p->loc_AmbientScale        = qglGetUniformLocationARB(p->program, "AmbientScale");
734                 p->loc_DiffuseScale        = qglGetUniformLocationARB(p->program, "DiffuseScale");
735                 p->loc_SpecularPower       = qglGetUniformLocationARB(p->program, "SpecularPower");
736                 p->loc_SpecularScale       = qglGetUniformLocationARB(p->program, "SpecularScale");
737                 p->loc_GlowScale           = qglGetUniformLocationARB(p->program, "GlowScale");
738                 p->loc_SceneBrightness     = qglGetUniformLocationARB(p->program, "SceneBrightness");
739                 p->loc_OffsetMapping_Scale = qglGetUniformLocationARB(p->program, "OffsetMapping_Scale");
740                 p->loc_AmbientColor        = qglGetUniformLocationARB(p->program, "AmbientColor");
741                 p->loc_DiffuseColor        = qglGetUniformLocationARB(p->program, "DiffuseColor");
742                 p->loc_SpecularColor       = qglGetUniformLocationARB(p->program, "SpecularColor");
743                 p->loc_LightDir            = qglGetUniformLocationARB(p->program, "LightDir");
744                 if (p->loc_Texture_Normal >= 0)    qglUniform1iARB(p->loc_Texture_Normal, 0);
745                 if (p->loc_Texture_Color >= 0)     qglUniform1iARB(p->loc_Texture_Color, 1);
746                 if (p->loc_Texture_Gloss >= 0)     qglUniform1iARB(p->loc_Texture_Gloss, 2);
747                 if (p->loc_Texture_Cube >= 0)      qglUniform1iARB(p->loc_Texture_Cube, 3);
748                 if (p->loc_Texture_FogMask >= 0)   qglUniform1iARB(p->loc_Texture_FogMask, 4);
749                 if (p->loc_Texture_Pants >= 0)     qglUniform1iARB(p->loc_Texture_Pants, 5);
750                 if (p->loc_Texture_Shirt >= 0)     qglUniform1iARB(p->loc_Texture_Shirt, 6);
751                 if (p->loc_Texture_Lightmap >= 0)  qglUniform1iARB(p->loc_Texture_Lightmap, 7);
752                 if (p->loc_Texture_Deluxemap >= 0) qglUniform1iARB(p->loc_Texture_Deluxemap, 8);
753                 if (p->loc_Texture_Glow >= 0)      qglUniform1iARB(p->loc_Texture_Glow, 9);
754                 CHECKGLERROR
755                 qglUseProgramObjectARB(0);CHECKGLERROR
756         }
757         else
758                 Con_Printf("permutation%s failed for shader %s, some features may not work properly!\n", permutationname, "glsl/default.glsl");
759         if (shaderstring)
760                 Mem_Free(shaderstring);
761 }
762
763 void R_GLSL_Restart_f(void)
764 {
765         int i;
766         for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
767                 if (r_glsl_permutations[i].program)
768                         GL_Backend_FreeProgram(r_glsl_permutations[i].program);
769         memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
770 }
771
772 int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting)
773 {
774         // select a permutation of the lighting shader appropriate to this
775         // combination of texture, entity, light source, and fogging, only use the
776         // minimum features necessary to avoid wasting rendering time in the
777         // fragment shader on features that are not being used
778         int permutation = 0;
779         float specularscale = rsurface_texture->specularscale;
780         r_glsl_permutation = NULL;
781         if (r_shadow_rtlight)
782         {
783                 permutation |= SHADERPERMUTATION_MODE_LIGHTSOURCE;
784                 specularscale *= r_shadow_rtlight->specularscale;
785                 if (r_shadow_rtlight->currentcubemap != r_texture_whitecube)
786                         permutation |= SHADERPERMUTATION_CUBEFILTER;
787         }
788         else
789         {
790                 if (!(rsurface_texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
791                 {
792                         if (modellighting)
793                                 permutation |= SHADERPERMUTATION_MODE_LIGHTDIRECTION;
794                         else if (r_glsl_deluxemapping.integer >= 1 && rsurface_lightmaptexture)
795                         {
796                                 if (r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping)
797                                 {
798                                         if (r_refdef.worldmodel->brushq3.deluxemapping_modelspace)
799                                                 permutation |= SHADERPERMUTATION_MODE_LIGHTDIRECTIONMAP_MODELSPACE;
800                                         else
801                                                 permutation |= SHADERPERMUTATION_MODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
802                                 }
803                                 else if (r_glsl_deluxemapping.integer >= 2) // fake mode
804                                         permutation |= SHADERPERMUTATION_MODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
805                         }
806                 }
807                 if (rsurface_texture->skin.glow)
808                         permutation |= SHADERPERMUTATION_GLOW;
809         }
810         if (specularscale > 0)
811                 permutation |= SHADERPERMUTATION_SPECULAR;
812         if (r_refdef.fogenabled)
813                 permutation |= SHADERPERMUTATION_FOG;
814         if (rsurface_texture->colormapping)
815                 permutation |= SHADERPERMUTATION_COLORMAPPING;
816         if (r_glsl_offsetmapping.integer)
817         {
818                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
819                 if (r_glsl_offsetmapping_reliefmapping.integer)
820                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
821         }
822         if (!r_glsl_permutations[permutation].program)
823         {
824                 if (!r_glsl_permutations[permutation].compiled)
825                         R_GLSL_CompilePermutation(permutation);
826                 if (!r_glsl_permutations[permutation].program)
827                 {
828                         // remove features until we find a valid permutation
829                         int i;
830                         for (i = SHADERPERMUTATION_COUNT-1;;i>>=1)
831                         {
832                                 // reduce i more quickly whenever it would not remove any bits
833                                 if (permutation < i)
834                                         continue;
835                                 permutation &= i;
836                                 if (!r_glsl_permutations[permutation].compiled)
837                                         R_GLSL_CompilePermutation(permutation);
838                                 if (r_glsl_permutations[permutation].program)
839                                         break;
840                                 if (!i)
841                                         return 0; // utterly failed
842                         }
843                 }
844         }
845         r_glsl_permutation = r_glsl_permutations + permutation;
846         CHECKGLERROR
847         qglUseProgramObjectARB(r_glsl_permutation->program);CHECKGLERROR
848         R_Mesh_TexMatrix(0, &rsurface_texture->currenttexmatrix);
849         if (permutation & SHADERPERMUTATION_MODE_LIGHTSOURCE)
850         {
851                 if (r_glsl_permutation->loc_Texture_Cube >= 0 && r_shadow_rtlight) R_Mesh_TexBindCubeMap(3, R_GetTexture(r_shadow_rtlight->currentcubemap));
852                 if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, r_shadow_entitylightorigin[0], r_shadow_entitylightorigin[1], r_shadow_entitylightorigin[2]);
853                 if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
854                 if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, r_shadow_rtlight->ambientscale);
855                 if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, r_shadow_rtlight->diffusescale);
856                 if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, specularscale);
857         }
858         else if (permutation & SHADERPERMUTATION_MODE_LIGHTDIRECTION)
859         {
860                 if (r_glsl_permutation->loc_AmbientColor >= 0)
861                         qglUniform3fARB(r_glsl_permutation->loc_AmbientColor, rsurface_entity->modellight_ambient[0], rsurface_entity->modellight_ambient[1], rsurface_entity->modellight_ambient[2]);
862                 if (r_glsl_permutation->loc_DiffuseColor >= 0)
863                         qglUniform3fARB(r_glsl_permutation->loc_DiffuseColor, rsurface_entity->modellight_diffuse[0], rsurface_entity->modellight_diffuse[1], rsurface_entity->modellight_diffuse[2]);
864                 if (r_glsl_permutation->loc_SpecularColor >= 0)
865                         qglUniform3fARB(r_glsl_permutation->loc_SpecularColor, rsurface_entity->modellight_diffuse[0] * rsurface_texture->specularscale, rsurface_entity->modellight_diffuse[1] * rsurface_texture->specularscale, rsurface_entity->modellight_diffuse[2] * rsurface_texture->specularscale);
866                 if (r_glsl_permutation->loc_LightDir >= 0)
867                         qglUniform3fARB(r_glsl_permutation->loc_LightDir, rsurface_entity->modellight_lightdir[0], rsurface_entity->modellight_lightdir[1], rsurface_entity->modellight_lightdir[2]);
868         }
869         else
870         {
871                 if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, r_ambient.value * 2.0f / 128.0f);
872                 if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, r_refdef.lightmapintensity * 2.0f);
873                 if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, r_refdef.lightmapintensity * specularscale * 2.0f);
874         }
875         if (r_glsl_permutation->loc_Texture_Normal >= 0) R_Mesh_TexBind(0, R_GetTexture(rsurface_texture->skin.nmap));
876         if (r_glsl_permutation->loc_Texture_Color >= 0) R_Mesh_TexBind(1, R_GetTexture(rsurface_texture->basetexture));
877         if (r_glsl_permutation->loc_Texture_Gloss >= 0) R_Mesh_TexBind(2, R_GetTexture(rsurface_texture->glosstexture));
878         //if (r_glsl_permutation->loc_Texture_Cube >= 0 && permutation & SHADERPERMUTATION_MODE_LIGHTSOURCE) R_Mesh_TexBindCubeMap(3, R_GetTexture(r_shadow_rtlight->currentcubemap));
879         if (r_glsl_permutation->loc_Texture_FogMask >= 0) R_Mesh_TexBind(4, R_GetTexture(r_texture_fogattenuation));
880         if (r_glsl_permutation->loc_Texture_Pants >= 0) R_Mesh_TexBind(5, R_GetTexture(rsurface_texture->skin.pants));
881         if (r_glsl_permutation->loc_Texture_Shirt >= 0) R_Mesh_TexBind(6, R_GetTexture(rsurface_texture->skin.shirt));
882         //if (r_glsl_permutation->loc_Texture_Lightmap >= 0) R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
883         //if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
884         if (r_glsl_permutation->loc_Texture_Glow >= 0) R_Mesh_TexBind(9, R_GetTexture(rsurface_texture->skin.glow));
885         if (r_glsl_permutation->loc_GlowScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_GlowScale, r_hdr_glowintensity.value);
886         if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale);
887         if (r_glsl_permutation->loc_FogColor >= 0)
888         {
889                 // additive passes are only darkened by fog, not tinted
890                 if (r_shadow_rtlight || (rsurface_texture->currentmaterialflags & MATERIALFLAG_ADD))
891                         qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
892                 else
893                         qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
894         }
895         if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface_modelorg[0], rsurface_modelorg[1], rsurface_modelorg[2]);
896         if (r_glsl_permutation->loc_Color_Pants >= 0)
897         {
898                 if (rsurface_texture->skin.pants)
899                         qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface_entity->colormap_pantscolor[0], rsurface_entity->colormap_pantscolor[1], rsurface_entity->colormap_pantscolor[2]);
900                 else
901                         qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, 0, 0, 0);
902         }
903         if (r_glsl_permutation->loc_Color_Shirt >= 0)
904         {
905                 if (rsurface_texture->skin.shirt)
906                         qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface_entity->colormap_shirtcolor[0], rsurface_entity->colormap_shirtcolor[1], rsurface_entity->colormap_shirtcolor[2]);
907                 else
908                         qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
909         }
910         if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, r_refdef.fograngerecip);
911         if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface_texture->specularpower);
912         if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);
913         CHECKGLERROR
914         return permutation;
915 }
916
917 void R_SwitchSurfaceShader(int permutation)
918 {
919         if (r_glsl_permutation != r_glsl_permutations + permutation)
920         {
921                 r_glsl_permutation = r_glsl_permutations + permutation;
922                 CHECKGLERROR
923                 qglUseProgramObjectARB(r_glsl_permutation->program);
924                 CHECKGLERROR
925         }
926 }
927
928 void gl_main_start(void)
929 {
930         r_main_texturepool = R_AllocTexturePool();
931         r_bloom_texture_screen = NULL;
932         r_bloom_texture_bloom = NULL;
933         R_BuildBlankTextures();
934         R_BuildNoTexture();
935         if (gl_texturecubemap)
936         {
937                 R_BuildWhiteCube();
938                 R_BuildNormalizationCube();
939         }
940         R_BuildFogTexture();
941         memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
942 }
943
944 void gl_main_shutdown(void)
945 {
946         R_FreeTexturePool(&r_main_texturepool);
947         r_bloom_texture_screen = NULL;
948         r_bloom_texture_bloom = NULL;
949         r_texture_blanknormalmap = NULL;
950         r_texture_white = NULL;
951         r_texture_black = NULL;
952         r_texture_whitecube = NULL;
953         r_texture_normalizationcube = NULL;
954         R_GLSL_Restart_f();
955 }
956
957 extern void CL_ParseEntityLump(char *entitystring);
958 void gl_main_newmap(void)
959 {
960         // FIXME: move this code to client
961         int l;
962         char *entities, entname[MAX_QPATH];
963         if (cl.worldmodel)
964         {
965                 strlcpy(entname, cl.worldmodel->name, sizeof(entname));
966                 l = (int)strlen(entname) - 4;
967                 if (l >= 0 && !strcmp(entname + l, ".bsp"))
968                 {
969                         memcpy(entname + l, ".ent", 5);
970                         if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
971                         {
972                                 CL_ParseEntityLump(entities);
973                                 Mem_Free(entities);
974                                 return;
975                         }
976                 }
977                 if (cl.worldmodel->brush.entities)
978                         CL_ParseEntityLump(cl.worldmodel->brush.entities);
979         }
980 }
981
982 void GL_Main_Init(void)
983 {
984         r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
985
986         Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed\n");
987         FOG_registercvars(); // FIXME: move this fog stuff to client?
988         Cvar_RegisterVariable(&r_nearclip);
989         Cvar_RegisterVariable(&r_showsurfaces);
990         Cvar_RegisterVariable(&r_showtris);
991         Cvar_RegisterVariable(&r_shownormals);
992         Cvar_RegisterVariable(&r_showlighting);
993         Cvar_RegisterVariable(&r_showshadowvolumes);
994         Cvar_RegisterVariable(&r_showcollisionbrushes);
995         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
996         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
997         Cvar_RegisterVariable(&r_showdisabledepthtest);
998         Cvar_RegisterVariable(&r_drawportals);
999         Cvar_RegisterVariable(&r_drawentities);
1000         Cvar_RegisterVariable(&r_drawviewmodel);
1001         Cvar_RegisterVariable(&r_speeds);
1002         Cvar_RegisterVariable(&r_fullbrights);
1003         Cvar_RegisterVariable(&r_wateralpha);
1004         Cvar_RegisterVariable(&r_dynamic);
1005         Cvar_RegisterVariable(&r_fullbright);
1006         Cvar_RegisterVariable(&r_q1bsp_skymasking);
1007         Cvar_RegisterVariable(&r_textureunits);
1008         Cvar_RegisterVariable(&r_glsl);
1009         Cvar_RegisterVariable(&r_glsl_offsetmapping);
1010         Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
1011         Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
1012         Cvar_RegisterVariable(&r_glsl_deluxemapping);
1013         Cvar_RegisterVariable(&r_lerpsprites);
1014         Cvar_RegisterVariable(&r_lerpmodels);
1015         Cvar_RegisterVariable(&r_waterscroll);
1016         Cvar_RegisterVariable(&r_bloom);
1017         Cvar_RegisterVariable(&r_bloom_intensity);
1018         Cvar_RegisterVariable(&r_bloom_blur);
1019         Cvar_RegisterVariable(&r_bloom_resolution);
1020         Cvar_RegisterVariable(&r_bloom_power);
1021         Cvar_RegisterVariable(&r_hdr);
1022         Cvar_RegisterVariable(&r_hdr_scenebrightness);
1023         Cvar_RegisterVariable(&r_hdr_bloomintensity);
1024         Cvar_RegisterVariable(&r_hdr_glowintensity);
1025         Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
1026         Cvar_RegisterVariable(&developer_texturelogging);
1027         Cvar_RegisterVariable(&gl_lightmaps);
1028         Cvar_RegisterVariable(&r_test);
1029         Cvar_RegisterVariable(&r_batchmode);
1030         if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
1031                 Cvar_SetValue("r_fullbrights", 0);
1032         R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap);
1033 }
1034
1035 extern void R_Textures_Init(void);
1036 extern void GL_Draw_Init(void);
1037 extern void GL_Main_Init(void);
1038 extern void R_Shadow_Init(void);
1039 extern void R_Sky_Init(void);
1040 extern void GL_Surf_Init(void);
1041 extern void R_Light_Init(void);
1042 extern void R_Particles_Init(void);
1043 extern void R_Explosion_Init(void);
1044 extern void gl_backend_init(void);
1045 extern void Sbar_Init(void);
1046 extern void R_LightningBeams_Init(void);
1047 extern void Mod_RenderInit(void);
1048
1049 void Render_Init(void)
1050 {
1051         gl_backend_init();
1052         R_Textures_Init();
1053         GL_Main_Init();
1054         GL_Draw_Init();
1055         R_Shadow_Init();
1056         R_Sky_Init();
1057         GL_Surf_Init();
1058         Sbar_Init();
1059         R_Light_Init();
1060         R_Particles_Init();
1061         R_Explosion_Init();
1062         R_LightningBeams_Init();
1063         Mod_RenderInit();
1064 }
1065
1066 /*
1067 ===============
1068 GL_Init
1069 ===============
1070 */
1071 extern char *ENGINE_EXTENSIONS;
1072 void GL_Init (void)
1073 {
1074         VID_CheckExtensions();
1075
1076         // LordHavoc: report supported extensions
1077         Con_DPrintf("\nengine extensions: %s\n", vm_sv_extensions );
1078
1079         // clear to black (loading plaque will be seen over this)
1080         CHECKGLERROR
1081         qglClearColor(0,0,0,1);CHECKGLERROR
1082         qglClear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
1083 }
1084
1085 int R_CullBox(const vec3_t mins, const vec3_t maxs)
1086 {
1087         int i;
1088         mplane_t *p;
1089         for (i = 0;i < 4;i++)
1090         {
1091                 p = r_view.frustum + i;
1092                 switch(p->signbits)
1093                 {
1094                 default:
1095                 case 0:
1096                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
1097                                 return true;
1098                         break;
1099                 case 1:
1100                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
1101                                 return true;
1102                         break;
1103                 case 2:
1104                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
1105                                 return true;
1106                         break;
1107                 case 3:
1108                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
1109                                 return true;
1110                         break;
1111                 case 4:
1112                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
1113                                 return true;
1114                         break;
1115                 case 5:
1116                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
1117                                 return true;
1118                         break;
1119                 case 6:
1120                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
1121                                 return true;
1122                         break;
1123                 case 7:
1124                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
1125                                 return true;
1126                         break;
1127                 }
1128         }
1129         return false;
1130 }
1131
1132 //==================================================================================
1133
1134 static void R_UpdateEntityLighting(entity_render_t *ent)
1135 {
1136         vec3_t tempdiffusenormal;
1137         VectorSet(ent->modellight_ambient, r_ambient.value * (2.0f / 128.0f), r_ambient.value * (2.0f / 128.0f), r_ambient.value * (2.0f / 128.0f));
1138         VectorClear(ent->modellight_diffuse);
1139         VectorClear(ent->modellight_lightdir);
1140         if ((ent->flags & RENDER_LIGHT) && r_refdef.worldmodel && r_refdef.worldmodel->brush.LightPoint)
1141         {
1142                 vec3_t org;
1143                 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
1144                 r_refdef.worldmodel->brush.LightPoint(r_refdef.worldmodel, org, ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal);
1145         }
1146         else // highly rare
1147                 VectorSet(ent->modellight_ambient, 1, 1, 1);
1148         Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, ent->modellight_lightdir);
1149         VectorNormalize(ent->modellight_lightdir);
1150         ent->modellight_ambient[0] *= ent->colormod[0] * r_refdef.lightmapintensity;
1151         ent->modellight_ambient[1] *= ent->colormod[1] * r_refdef.lightmapintensity;
1152         ent->modellight_ambient[2] *= ent->colormod[2] * r_refdef.lightmapintensity;
1153         ent->modellight_diffuse[0] *= ent->colormod[0] * r_refdef.lightmapintensity;
1154         ent->modellight_diffuse[1] *= ent->colormod[1] * r_refdef.lightmapintensity;
1155         ent->modellight_diffuse[2] *= ent->colormod[2] * r_refdef.lightmapintensity;
1156 }
1157
1158 static void R_View_UpdateEntityVisible (void)
1159 {
1160         int i, renderimask;
1161         entity_render_t *ent;
1162
1163         if (!r_drawentities.integer)
1164                 return;
1165
1166         renderimask = r_refdef.envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL) : (chase_active.integer ? 0 : RENDER_EXTERIORMODEL);
1167         if (r_refdef.worldmodel && r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs)
1168         {
1169                 // worldmodel can check visibility
1170                 for (i = 0;i < r_refdef.numentities;i++)
1171                 {
1172                         ent = r_refdef.entities[i];
1173                         r_viewcache.entityvisible[i] = !(ent->flags & renderimask) && !R_CullBox(ent->mins, ent->maxs) && ((ent->effects & EF_NODEPTHTEST) || r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.worldmodel, r_viewcache.world_leafvisible, ent->mins, ent->maxs));
1174                 }
1175         }
1176         else
1177         {
1178                 // no worldmodel or it can't check visibility
1179                 for (i = 0;i < r_refdef.numentities;i++)
1180                 {
1181                         ent = r_refdef.entities[i];
1182                         r_viewcache.entityvisible[i] = !(ent->flags & renderimask) && !R_CullBox(ent->mins, ent->maxs) && (ent->effects & EF_NODEPTHTEST);
1183                 }
1184         }
1185 }
1186
1187 // only used if skyrendermasked, and normally returns false
1188 int R_DrawBrushModelsSky (void)
1189 {
1190         int i, sky;
1191         entity_render_t *ent;
1192
1193         if (!r_drawentities.integer)
1194                 return false;
1195
1196         sky = false;
1197         for (i = 0;i < r_refdef.numentities;i++)
1198         {
1199                 if (!r_viewcache.entityvisible[i])
1200                         continue;
1201                 ent = r_refdef.entities[i];
1202                 if (!ent->model || !ent->model->DrawSky)
1203                         continue;
1204                 ent->model->DrawSky(ent);
1205                 sky = true;
1206         }
1207         return sky;
1208 }
1209
1210 void R_DrawNoModel(entity_render_t *ent);
1211 void R_DrawModels(void)
1212 {
1213         int i;
1214         entity_render_t *ent;
1215
1216         if (!r_drawentities.integer)
1217                 return;
1218
1219         for (i = 0;i < r_refdef.numentities;i++)
1220         {
1221                 if (!r_viewcache.entityvisible[i])
1222                         continue;
1223                 ent = r_refdef.entities[i];
1224                 r_refdef.stats.entities++;
1225                 if (ent->model && ent->model->Draw != NULL)
1226                         ent->model->Draw(ent);
1227                 else
1228                         R_DrawNoModel(ent);
1229         }
1230 }
1231
1232 static void R_View_SetFrustum(void)
1233 {
1234         // break apart the view matrix into vectors for various purposes
1235         Matrix4x4_ToVectors(&r_view.matrix, r_view.forward, r_view.left, r_view.up, r_view.origin);
1236         VectorNegate(r_view.left, r_view.right);
1237
1238 #if 0
1239         r_view.frustum[0].normal[0] = 0 - 1.0 / r_view.frustum_x;
1240         r_view.frustum[0].normal[1] = 0 - 0;
1241         r_view.frustum[0].normal[2] = -1 - 0;
1242         r_view.frustum[1].normal[0] = 0 + 1.0 / r_view.frustum_x;
1243         r_view.frustum[1].normal[1] = 0 + 0;
1244         r_view.frustum[1].normal[2] = -1 + 0;
1245         r_view.frustum[2].normal[0] = 0 - 0;
1246         r_view.frustum[2].normal[1] = 0 - 1.0 / r_view.frustum_y;
1247         r_view.frustum[2].normal[2] = -1 - 0;
1248         r_view.frustum[3].normal[0] = 0 + 0;
1249         r_view.frustum[3].normal[1] = 0 + 1.0 / r_view.frustum_y;
1250         r_view.frustum[3].normal[2] = -1 + 0;
1251 #endif
1252
1253 #if 0
1254         zNear = r_refdef.nearclip;
1255         nudge = 1.0 - 1.0 / (1<<23);
1256         r_view.frustum[4].normal[0] = 0 - 0;
1257         r_view.frustum[4].normal[1] = 0 - 0;
1258         r_view.frustum[4].normal[2] = -1 - -nudge;
1259         r_view.frustum[4].dist = 0 - -2 * zNear * nudge;
1260         r_view.frustum[5].normal[0] = 0 + 0;
1261         r_view.frustum[5].normal[1] = 0 + 0;
1262         r_view.frustum[5].normal[2] = -1 + -nudge;
1263         r_view.frustum[5].dist = 0 + -2 * zNear * nudge;
1264 #endif
1265
1266
1267
1268 #if 0
1269         r_view.frustum[0].normal[0] = m[3] - m[0];
1270         r_view.frustum[0].normal[1] = m[7] - m[4];
1271         r_view.frustum[0].normal[2] = m[11] - m[8];
1272         r_view.frustum[0].dist = m[15] - m[12];
1273
1274         r_view.frustum[1].normal[0] = m[3] + m[0];
1275         r_view.frustum[1].normal[1] = m[7] + m[4];
1276         r_view.frustum[1].normal[2] = m[11] + m[8];
1277         r_view.frustum[1].dist = m[15] + m[12];
1278
1279         r_view.frustum[2].normal[0] = m[3] - m[1];
1280         r_view.frustum[2].normal[1] = m[7] - m[5];
1281         r_view.frustum[2].normal[2] = m[11] - m[9];
1282         r_view.frustum[2].dist = m[15] - m[13];
1283
1284         r_view.frustum[3].normal[0] = m[3] + m[1];
1285         r_view.frustum[3].normal[1] = m[7] + m[5];
1286         r_view.frustum[3].normal[2] = m[11] + m[9];
1287         r_view.frustum[3].dist = m[15] + m[13];
1288
1289         r_view.frustum[4].normal[0] = m[3] - m[2];
1290         r_view.frustum[4].normal[1] = m[7] - m[6];
1291         r_view.frustum[4].normal[2] = m[11] - m[10];
1292         r_view.frustum[4].dist = m[15] - m[14];
1293
1294         r_view.frustum[5].normal[0] = m[3] + m[2];
1295         r_view.frustum[5].normal[1] = m[7] + m[6];
1296         r_view.frustum[5].normal[2] = m[11] + m[10];
1297         r_view.frustum[5].dist = m[15] + m[14];
1298 #endif
1299
1300
1301
1302         VectorMAM(1, r_view.forward, 1.0 / -r_view.frustum_x, r_view.left, r_view.frustum[0].normal);
1303         VectorMAM(1, r_view.forward, 1.0 /  r_view.frustum_x, r_view.left, r_view.frustum[1].normal);
1304         VectorMAM(1, r_view.forward, 1.0 / -r_view.frustum_y, r_view.up, r_view.frustum[2].normal);
1305         VectorMAM(1, r_view.forward, 1.0 /  r_view.frustum_y, r_view.up, r_view.frustum[3].normal);
1306         VectorCopy(r_view.forward, r_view.frustum[4].normal);
1307         VectorNormalize(r_view.frustum[0].normal);
1308         VectorNormalize(r_view.frustum[1].normal);
1309         VectorNormalize(r_view.frustum[2].normal);
1310         VectorNormalize(r_view.frustum[3].normal);
1311         r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal);
1312         r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal);
1313         r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal);
1314         r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal);
1315         r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
1316         PlaneClassify(&r_view.frustum[0]);
1317         PlaneClassify(&r_view.frustum[1]);
1318         PlaneClassify(&r_view.frustum[2]);
1319         PlaneClassify(&r_view.frustum[3]);
1320         PlaneClassify(&r_view.frustum[4]);
1321
1322         // LordHavoc: note to all quake engine coders, Quake had a special case
1323         // for 90 degrees which assumed a square view (wrong), so I removed it,
1324         // Quake2 has it disabled as well.
1325
1326         // rotate R_VIEWFORWARD right by FOV_X/2 degrees
1327         //RotatePointAroundVector( r_view.frustum[0].normal, r_view.up, r_view.forward, -(90 - r_refdef.fov_x / 2));
1328         //r_view.frustum[0].dist = DotProduct (r_view.origin, frustum[0].normal);
1329         //PlaneClassify(&frustum[0]);
1330
1331         // rotate R_VIEWFORWARD left by FOV_X/2 degrees
1332         //RotatePointAroundVector( r_view.frustum[1].normal, r_view.up, r_view.forward, (90 - r_refdef.fov_x / 2));
1333         //r_view.frustum[1].dist = DotProduct (r_view.origin, frustum[1].normal);
1334         //PlaneClassify(&frustum[1]);
1335
1336         // rotate R_VIEWFORWARD up by FOV_X/2 degrees
1337         //RotatePointAroundVector( r_view.frustum[2].normal, r_view.left, r_view.forward, -(90 - r_refdef.fov_y / 2));
1338         //r_view.frustum[2].dist = DotProduct (r_view.origin, frustum[2].normal);
1339         //PlaneClassify(&frustum[2]);
1340
1341         // rotate R_VIEWFORWARD down by FOV_X/2 degrees
1342         //RotatePointAroundVector( r_view.frustum[3].normal, r_view.left, r_view.forward, (90 - r_refdef.fov_y / 2));
1343         //r_view.frustum[3].dist = DotProduct (r_view.origin, frustum[3].normal);
1344         //PlaneClassify(&frustum[3]);
1345
1346         // nearclip plane
1347         //VectorCopy(r_view.forward, r_view.frustum[4].normal);
1348         //r_view.frustum[4].dist = DotProduct (r_view.origin, frustum[4].normal) + r_nearclip.value;
1349         //PlaneClassify(&frustum[4]);
1350 }
1351
1352 void R_View_Update(void)
1353 {
1354         R_View_SetFrustum();
1355         R_View_WorldVisibility();
1356         R_View_UpdateEntityVisible();
1357 }
1358
1359 void R_ResetViewRendering(void)
1360 {
1361         if (gl_support_fragment_shader)
1362         {
1363                 qglUseProgramObjectARB(0);CHECKGLERROR
1364         }
1365
1366         // GL is weird because it's bottom to top, r_view.y is top to bottom
1367         qglViewport(r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
1368         GL_SetupView_Mode_Ortho(0, 0, 1, 1, -10, 100);
1369         GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
1370         GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
1371         GL_ScissorTest(true);
1372         GL_DepthMask(true);
1373         GL_DepthTest(true);
1374         R_Mesh_Matrix(&identitymatrix);
1375         R_Mesh_ResetTextureState();
1376 }
1377
1378 void R_RenderScene(void);
1379
1380 void R_Bloom_MakeTexture(qboolean darken)
1381 {
1382         int screenwidth, screenheight;
1383         int screentexturewidth, screentextureheight;
1384         int bloomtexturewidth, bloomtextureheight;
1385         int bloomwidth, bloomheight, x, range;
1386         float xoffset, yoffset, r;
1387         float vertex3f[12];
1388         float texcoord2f[3][8];
1389
1390         // set bloomwidth and bloomheight to the bloom resolution that will be
1391         // used (often less than the screen resolution for faster rendering)
1392         bloomwidth = bound(1, r_bloom_resolution.integer, r_view.width);
1393         bloomheight = bound(1, bloomwidth * r_view.height / r_view.width, r_view.height);
1394
1395         // set the (poorly named) screenwidth and screenheight variables to
1396         // a power of 2 at least as large as the screen, these will define the
1397         // size of the texture to allocate
1398         for (screenwidth = 1;screenwidth < vid.width;screenwidth *= 2);
1399         for (screenheight = 1;screenheight < vid.height;screenheight *= 2);
1400
1401         r_refdef.stats.bloom++;
1402
1403         // allocate textures as needed
1404         // TODO: reallocate these when size settings change
1405         if (!r_bloom_texture_screen)
1406                 r_bloom_texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", screenwidth, screenheight, NULL, TEXTYPE_RGBA, TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
1407         if (!r_bloom_texture_bloom)
1408                 r_bloom_texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", screenwidth, screenheight, NULL, TEXTYPE_RGBA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
1409
1410         screentexturewidth = R_TextureWidth(r_bloom_texture_screen);
1411         screentextureheight = R_TextureHeight(r_bloom_texture_screen);
1412         bloomtexturewidth = R_TextureWidth(r_bloom_texture_bloom);
1413         bloomtextureheight = R_TextureHeight(r_bloom_texture_bloom);
1414
1415         // vertex coordinates for a quad that covers the screen exactly
1416         vertex3f[0] = 0;vertex3f[1] = 0;vertex3f[2] = 0;
1417         vertex3f[3] = 1;vertex3f[4] = 0;vertex3f[5] = 0;
1418         vertex3f[6] = 1;vertex3f[7] = 1;vertex3f[8] = 0;
1419         vertex3f[9] = 0;vertex3f[10] = 1;vertex3f[11] = 0;
1420
1421         // set up a texcoord array for the full resolution screen image
1422         // (we have to keep this around to copy back during final render)
1423         texcoord2f[0][0] = 0;
1424         texcoord2f[0][1] = (float)r_view.height / (float)screentextureheight;
1425         texcoord2f[0][2] = (float)r_view.width / (float)screentexturewidth;
1426         texcoord2f[0][3] = (float)r_view.height / (float)screentextureheight;
1427         texcoord2f[0][4] = (float)r_view.width / (float)screentexturewidth;
1428         texcoord2f[0][5] = 0;
1429         texcoord2f[0][6] = 0;
1430         texcoord2f[0][7] = 0;
1431
1432         // set up a texcoord array for the reduced resolution bloom image
1433         // (which will be additive blended over the screen image)
1434         texcoord2f[1][0] = 0;
1435         texcoord2f[1][1] = (float)bloomheight / (float)bloomtextureheight;
1436         texcoord2f[1][2] = (float)bloomwidth / (float)bloomtexturewidth;
1437         texcoord2f[1][3] = (float)bloomheight / (float)bloomtextureheight;
1438         texcoord2f[1][4] = (float)bloomwidth / (float)bloomtexturewidth;
1439         texcoord2f[1][5] = 0;
1440         texcoord2f[1][6] = 0;
1441         texcoord2f[1][7] = 0;
1442
1443         R_ResetViewRendering();
1444         GL_DepthTest(false);
1445         R_Mesh_VertexPointer(vertex3f);
1446         R_Mesh_ColorPointer(NULL);
1447
1448         R_Mesh_TexCoordPointer(0, 2, texcoord2f[0]);
1449         R_Mesh_TexBind(0, R_GetTexture(r_bloom_texture_screen));
1450
1451         // copy view into the screen texture
1452         GL_ActiveTexture(0);
1453         CHECKGLERROR
1454         qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
1455         r_refdef.stats.bloom_copypixels += r_view.width * r_view.height;
1456
1457         // now scale it down to the bloom texture size
1458         CHECKGLERROR
1459         qglViewport(r_view.x, vid.height - (r_view.y + bloomheight), bloomwidth, bloomheight);CHECKGLERROR
1460         GL_BlendFunc(GL_ONE, GL_ZERO);
1461         GL_Color(1, 1, 1, 1);
1462         // TODO: optimize with multitexture or GLSL
1463         R_Mesh_Draw(0, 4, 2, polygonelements);
1464         r_refdef.stats.bloom_drawpixels += bloomwidth * bloomheight;
1465
1466         if (darken)
1467         {
1468                 // raise to a power of itself to darken it (this leaves the really
1469                 // bright stuff bright, and everything else becomes very dark)
1470                 // render multiple times with a multiply blendfunc to raise to a power
1471                 GL_BlendFunc(GL_DST_COLOR, GL_ZERO);
1472                 for (x = 1;x < r_bloom_power.integer;x++)
1473                 {
1474                         R_Mesh_Draw(0, 4, 2, polygonelements);
1475                         r_refdef.stats.bloom_drawpixels += bloomwidth * bloomheight;
1476                 }
1477         }
1478
1479         // we now have a darkened bloom image in the framebuffer
1480         // copy it into the bloom image texture for more processing
1481         R_Mesh_TexBind(0, R_GetTexture(r_bloom_texture_bloom));
1482         R_Mesh_TexCoordPointer(0, 2, texcoord2f[2]);
1483         GL_ActiveTexture(0);
1484         CHECKGLERROR
1485         qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + bloomheight), bloomwidth, bloomheight);CHECKGLERROR
1486         r_refdef.stats.bloom_copypixels += bloomwidth * bloomheight;
1487
1488         // blend on at multiple vertical offsets to achieve a vertical blur
1489         // TODO: do offset blends using GLSL
1490         range = r_bloom_blur.integer * bloomwidth / 320;
1491         GL_BlendFunc(GL_ONE, GL_ZERO);
1492         for (x = -range;x <= range;x++)
1493         {
1494                 xoffset = 0 / (float)bloomwidth * (float)bloomwidth / (float)screenwidth;
1495                 yoffset = x / (float)bloomheight * (float)bloomheight / (float)screenheight;
1496                 // compute a texcoord array with the specified x and y offset
1497                 texcoord2f[2][0] = xoffset+0;
1498                 texcoord2f[2][1] = yoffset+(float)bloomheight / (float)screenheight;
1499                 texcoord2f[2][2] = xoffset+(float)bloomwidth / (float)screenwidth;
1500                 texcoord2f[2][3] = yoffset+(float)bloomheight / (float)screenheight;
1501                 texcoord2f[2][4] = xoffset+(float)bloomwidth / (float)screenwidth;
1502                 texcoord2f[2][5] = yoffset+0;
1503                 texcoord2f[2][6] = xoffset+0;
1504                 texcoord2f[2][7] = yoffset+0;
1505                 // this r value looks like a 'dot' particle, fading sharply to
1506                 // black at the edges
1507                 // (probably not realistic but looks good enough)
1508                 r = r_bloom_intensity.value/(range*2+1)*(1 - x*x/(float)(range*range));
1509                 if (r < 0.01f)
1510                         continue;
1511                 GL_Color(r, r, r, 1);
1512                 R_Mesh_Draw(0, 4, 2, polygonelements);
1513                 r_refdef.stats.bloom_drawpixels += bloomwidth * bloomheight;
1514                 GL_BlendFunc(GL_ONE, GL_ONE);
1515         }
1516
1517         // copy the vertically blurred bloom view to a texture
1518         GL_ActiveTexture(0);
1519         CHECKGLERROR
1520         qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + bloomheight), bloomwidth, bloomheight);CHECKGLERROR
1521         r_refdef.stats.bloom_copypixels += bloomwidth * bloomheight;
1522
1523         // blend the vertically blurred image at multiple offsets horizontally
1524         // to finish the blur effect
1525         // TODO: do offset blends using GLSL
1526         range = r_bloom_blur.integer * bloomwidth / 320;
1527         GL_BlendFunc(GL_ONE, GL_ZERO);
1528         for (x = -range;x <= range;x++)
1529         {
1530                 xoffset = x / (float)bloomwidth * (float)bloomwidth / (float)screenwidth;
1531                 yoffset = 0 / (float)bloomheight * (float)bloomheight / (float)screenheight;
1532                 // compute a texcoord array with the specified x and y offset
1533                 texcoord2f[2][0] = xoffset+0;
1534                 texcoord2f[2][1] = yoffset+(float)bloomheight / (float)screenheight;
1535                 texcoord2f[2][2] = xoffset+(float)bloomwidth / (float)screenwidth;
1536                 texcoord2f[2][3] = yoffset+(float)bloomheight / (float)screenheight;
1537                 texcoord2f[2][4] = xoffset+(float)bloomwidth / (float)screenwidth;
1538                 texcoord2f[2][5] = yoffset+0;
1539                 texcoord2f[2][6] = xoffset+0;
1540                 texcoord2f[2][7] = yoffset+0;
1541                 // this r value looks like a 'dot' particle, fading sharply to
1542                 // black at the edges
1543                 // (probably not realistic but looks good enough)
1544                 r = r_bloom_intensity.value/(range*2+1)*(1 - x*x/(float)(range*range));
1545                 if (r < 0.01f)
1546                         continue;
1547                 GL_Color(r, r, r, 1);
1548                 R_Mesh_Draw(0, 4, 2, polygonelements);
1549                 r_refdef.stats.bloom_drawpixels += bloomwidth * bloomheight;
1550                 GL_BlendFunc(GL_ONE, GL_ONE);
1551         }
1552
1553         // copy the blurred bloom view to a texture
1554         GL_ActiveTexture(0);
1555         CHECKGLERROR
1556         qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + bloomheight), bloomwidth, bloomheight);CHECKGLERROR
1557         r_refdef.stats.bloom_copypixels += bloomwidth * bloomheight;
1558 }
1559
1560 void R_HDR_RenderBloomTexture(void)
1561 {
1562         int oldwidth, oldheight;
1563
1564         oldwidth = r_view.width;
1565         oldheight = r_view.height;
1566         r_view.width = bound(1, r_bloom_resolution.integer, min(r_view.width, gl_max_texture_size));
1567         r_view.height = r_view.width * oldheight / oldwidth;
1568
1569         // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer?  it might improve SLI performance.
1570         // FIXME: change global lightmapintensity and light intensity according to r_hdr_bloomintensity cvar
1571         // FIXME: change global lightmapintensity and light intensity according to r_hdr_scenebrightness cvar
1572         // TODO: add exposure compensation features
1573
1574         r_view.colorscale = r_hdr_bloomintensity.value * r_hdr_scenebrightness.value;
1575         R_RenderScene();
1576
1577         R_ResetViewRendering();
1578
1579         R_Bloom_MakeTexture(false);
1580
1581         R_ClearScreen();
1582         if (r_timereport_active)
1583                 R_TimeReport("clear");
1584
1585         // restore the view settings
1586         r_view.width = oldwidth;
1587         r_view.height = oldheight;
1588
1589         // go back to full view area
1590         R_ResetViewRendering();
1591 }
1592
1593 static void R_BlendView(void)
1594 {
1595         int screenwidth, screenheight;
1596         int bloomwidth, bloomheight;
1597         qboolean dobloom;
1598         qboolean dohdr;
1599         qboolean doblend;
1600         float vertex3f[12];
1601         float texcoord2f[3][8];
1602
1603         // set the (poorly named) screenwidth and screenheight variables to
1604         // a power of 2 at least as large as the screen, these will define the
1605         // size of the texture to allocate
1606         for (screenwidth = 1;screenwidth < vid.width;screenwidth *= 2);
1607         for (screenheight = 1;screenheight < vid.height;screenheight *= 2);
1608
1609         doblend = r_refdef.viewblend[3] >= 0.01f;
1610         dobloom = !r_hdr.integer && r_bloom.integer && screenwidth <= gl_max_texture_size && screenheight <= gl_max_texture_size && r_bloom_resolution.value >= 32 && r_bloom_power.integer >= 1 && r_bloom_power.integer < 100 && r_bloom_blur.value >= 0 && r_bloom_blur.value < 512;
1611         dohdr = r_hdr.integer && screenwidth <= gl_max_texture_size && screenheight <= gl_max_texture_size && r_bloom_resolution.value >= 32 && r_bloom_power.integer >= 1 && r_bloom_power.integer < 100 && r_bloom_blur.value >= 0 && r_bloom_blur.value < 512;
1612
1613         if (!dobloom && !dohdr && !doblend)
1614                 return;
1615
1616         // vertex coordinates for a quad that covers the screen exactly
1617         vertex3f[0] = 0;vertex3f[1] = 0;vertex3f[2] = 0;
1618         vertex3f[3] = 1;vertex3f[4] = 0;vertex3f[5] = 0;
1619         vertex3f[6] = 1;vertex3f[7] = 1;vertex3f[8] = 0;
1620         vertex3f[9] = 0;vertex3f[10] = 1;vertex3f[11] = 0;
1621
1622         // set bloomwidth and bloomheight to the bloom resolution that will be
1623         // used (often less than the screen resolution for faster rendering)
1624         bloomwidth = min(r_view.width, r_bloom_resolution.integer);
1625         bloomheight = min(r_view.height, bloomwidth * r_view.height / r_view.width);
1626         // set up a texcoord array for the full resolution screen image
1627         // (we have to keep this around to copy back during final render)
1628         texcoord2f[0][0] = 0;
1629         texcoord2f[0][1] = (float)r_view.height / (float)screenheight;
1630         texcoord2f[0][2] = (float)r_view.width / (float)screenwidth;
1631         texcoord2f[0][3] = (float)r_view.height / (float)screenheight;
1632         texcoord2f[0][4] = (float)r_view.width / (float)screenwidth;
1633         texcoord2f[0][5] = 0;
1634         texcoord2f[0][6] = 0;
1635         texcoord2f[0][7] = 0;
1636         // set up a texcoord array for the reduced resolution bloom image
1637         // (which will be additive blended over the screen image)
1638         texcoord2f[1][0] = 0;
1639         texcoord2f[1][1] = (float)bloomheight / (float)screenheight;
1640         texcoord2f[1][2] = (float)bloomwidth / (float)screenwidth;
1641         texcoord2f[1][3] = (float)bloomheight / (float)screenheight;
1642         texcoord2f[1][4] = (float)bloomwidth / (float)screenwidth;
1643         texcoord2f[1][5] = 0;
1644         texcoord2f[1][6] = 0;
1645         texcoord2f[1][7] = 0;
1646
1647         if (dohdr)
1648         {
1649                 // render high dynamic range bloom effect
1650                 // the bloom texture was made earlier this render, so we just need to
1651                 // blend it onto the screen...
1652                 R_ResetViewRendering();
1653                 GL_DepthTest(false);
1654                 R_Mesh_VertexPointer(vertex3f);
1655                 R_Mesh_ColorPointer(NULL);
1656                 GL_Color(1, 1, 1, 1);
1657                 GL_BlendFunc(GL_ONE, GL_ONE);
1658                 R_Mesh_TexBind(0, R_GetTexture(r_bloom_texture_bloom));
1659                 R_Mesh_TexCoordPointer(0, 2, texcoord2f[1]);
1660                 R_Mesh_Draw(0, 4, 2, polygonelements);
1661                 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
1662         }
1663         if (dobloom)
1664         {
1665                 // render simple bloom effect
1666                 // make the bloom texture
1667                 R_Bloom_MakeTexture(true);
1668                 // put the original screen image back in place and blend the bloom
1669                 // texture on it
1670                 R_ResetViewRendering();
1671                 GL_DepthTest(false);
1672                 R_Mesh_VertexPointer(vertex3f);
1673                 R_Mesh_ColorPointer(NULL);
1674                 GL_Color(1, 1, 1, 1);
1675                 GL_BlendFunc(GL_ONE, GL_ZERO);
1676                 // do both in one pass if possible
1677                 R_Mesh_TexBind(0, R_GetTexture(r_bloom_texture_screen));
1678                 R_Mesh_TexCoordPointer(0, 2, texcoord2f[0]);
1679                 if (r_textureunits.integer >= 2 && gl_combine.integer)
1680                 {
1681                         R_Mesh_TexCombine(1, GL_ADD, GL_ADD, 1, 1);
1682                         R_Mesh_TexBind(1, R_GetTexture(r_bloom_texture_bloom));
1683                         R_Mesh_TexCoordPointer(1, 2, texcoord2f[1]);
1684                 }
1685                 else
1686                 {
1687                         R_Mesh_Draw(0, 4, 2, polygonelements);
1688                         r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
1689                         // now blend on the bloom texture
1690                         GL_BlendFunc(GL_ONE, GL_ONE);
1691                         R_Mesh_TexBind(0, R_GetTexture(r_bloom_texture_bloom));
1692                         R_Mesh_TexCoordPointer(0, 2, texcoord2f[1]);
1693                 }
1694                 R_Mesh_Draw(0, 4, 2, polygonelements);
1695                 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
1696         }
1697         if (doblend)
1698         {
1699                 // apply a color tint to the whole view
1700                 R_ResetViewRendering();
1701                 GL_DepthTest(false);
1702                 R_Mesh_VertexPointer(vertex3f);
1703                 R_Mesh_ColorPointer(NULL);
1704                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1705                 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
1706                 R_Mesh_Draw(0, 4, 2, polygonelements);
1707         }
1708 }
1709
1710 void R_RenderScene(void);
1711
1712 matrix4x4_t r_waterscrollmatrix;
1713
1714 void R_UpdateVariables(void)
1715 {
1716         int i;
1717
1718         R_Textures_Frame();
1719
1720         r_refdef.farclip = 4096;
1721         if (r_refdef.worldmodel)
1722                 r_refdef.farclip += VectorDistance(r_refdef.worldmodel->normalmins, r_refdef.worldmodel->normalmaxs);
1723         r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
1724
1725         r_refdef.polygonfactor = 0;
1726         r_refdef.polygonoffset = 0;
1727         r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_shadow_polygonfactor.value;
1728         r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_shadow_polygonoffset.value;
1729
1730         r_refdef.rtworld = r_shadow_realtime_world.integer;
1731         r_refdef.rtworldshadows = r_shadow_realtime_world_shadows.integer && gl_stencil;
1732         r_refdef.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer;
1733         r_refdef.rtdlightshadows = r_refdef.rtdlight && (r_refdef.rtworld ? r_shadow_realtime_world_dlightshadows.integer : r_shadow_realtime_dlight_shadows.integer) && gl_stencil;
1734         r_refdef.lightmapintensity = r_refdef.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
1735         if (r_showsurfaces.integer)
1736         {
1737                 r_refdef.rtworld = false;
1738                 r_refdef.rtworldshadows = false;
1739                 r_refdef.rtdlight = false;
1740                 r_refdef.rtdlightshadows = false;
1741                 r_refdef.lightmapintensity = 0;
1742         }
1743
1744         if (gamemode == GAME_NEHAHRA)
1745         {
1746                 if (gl_fogenable.integer)
1747                 {
1748                         r_refdef.oldgl_fogenable = true;
1749                         r_refdef.fog_density = gl_fogdensity.value;
1750                         r_refdef.fog_red = gl_fogred.value;
1751                         r_refdef.fog_green = gl_foggreen.value;
1752                         r_refdef.fog_blue = gl_fogblue.value;
1753                 }
1754                 else if (r_refdef.oldgl_fogenable)
1755                 {
1756                         r_refdef.oldgl_fogenable = false;
1757                         r_refdef.fog_density = 0;
1758                         r_refdef.fog_red = 0;
1759                         r_refdef.fog_green = 0;
1760                         r_refdef.fog_blue = 0;
1761                 }
1762         }
1763         if (r_refdef.fog_density)
1764         {
1765                 r_refdef.fogcolor[0] = bound(0.0f, r_refdef.fog_red  , 1.0f);
1766                 r_refdef.fogcolor[1] = bound(0.0f, r_refdef.fog_green, 1.0f);
1767                 r_refdef.fogcolor[2] = bound(0.0f, r_refdef.fog_blue , 1.0f);
1768         }
1769         if (r_refdef.fog_density)
1770         {
1771                 r_refdef.fogenabled = true;
1772                 // this is the point where the fog reaches 0.9986 alpha, which we
1773                 // consider a good enough cutoff point for the texture
1774                 // (0.9986 * 256 == 255.6)
1775                 r_refdef.fogrange = 400 / r_refdef.fog_density;
1776                 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
1777                 r_refdef.fogtabledistmultiplier = FOGTABLEWIDTH * r_refdef.fograngerecip;
1778                 // fog color was already set
1779         }
1780         else
1781                 r_refdef.fogenabled = false;
1782
1783         // update some cached entity properties...
1784         for (i = 0;i < r_refdef.numentities;i++)
1785         {
1786                 entity_render_t *ent = r_refdef.entities[i];
1787                 R_UpdateEntityLighting(ent);
1788         }
1789 }
1790
1791 /*
1792 ================
1793 R_RenderView
1794 ================
1795 */
1796 void R_RenderView(void)
1797 {
1798         if (!r_refdef.entities/* || !r_refdef.worldmodel*/)
1799                 return; //Host_Error ("R_RenderView: NULL worldmodel");
1800
1801         CHECKGLERROR
1802         GL_ScissorTest(true);
1803         GL_DepthMask(true);
1804         if (r_timereport_active)
1805                 R_TimeReport("setup");
1806
1807         R_View_Update();
1808         if (r_timereport_active)
1809                 R_TimeReport("visibility");
1810
1811         R_ResetViewRendering();
1812
1813         R_ClearScreen();
1814         if (r_timereport_active)
1815                 R_TimeReport("clear");
1816
1817         // this produces a bloom texture to be used in R_BlendView() later
1818         if (r_hdr.integer)
1819                 R_HDR_RenderBloomTexture();
1820
1821         r_view.colorscale = r_hdr_scenebrightness.value;
1822         R_RenderScene();
1823
1824         R_BlendView();
1825         if (r_timereport_active)
1826                 R_TimeReport("blendview");
1827
1828         GL_Scissor(0, 0, vid.width, vid.height);
1829         GL_ScissorTest(false);
1830         CHECKGLERROR
1831 }
1832
1833 extern void R_DrawLightningBeams (void);
1834 extern void VM_AddPolygonsToMeshQueue (void);
1835 extern void R_DrawPortals (void);
1836 void R_RenderScene(void)
1837 {
1838         DrawQ_Finish();
1839
1840         // don't let sound skip if going slow
1841         if (r_refdef.extraupdate)
1842                 S_ExtraUpdate ();
1843
1844         CHECKGLERROR
1845         if (gl_support_fragment_shader)
1846         {
1847                 qglUseProgramObjectARB(0);CHECKGLERROR
1848         }
1849         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
1850         qglPolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
1851         qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
1852
1853         R_ResetViewRendering();
1854
1855         R_MeshQueue_BeginScene();
1856
1857         if (r_refdef.rtworldshadows || r_refdef.rtdlightshadows)
1858                 GL_SetupView_Mode_PerspectiveInfiniteFarClip(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip);
1859         else
1860                 GL_SetupView_Mode_Perspective(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip, r_refdef.farclip);
1861
1862         GL_SetupView_Orientation_FromEntity(&r_view.matrix);
1863
1864         R_Shadow_UpdateWorldLightSelection();
1865
1866         R_SkyStartFrame();
1867
1868         Matrix4x4_CreateTranslate(&r_waterscrollmatrix, sin(r_refdef.time) * 0.025 * r_waterscroll.value, sin(r_refdef.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
1869
1870         if (cl.csqc_vidvars.drawworld)
1871         {
1872                 // don't let sound skip if going slow
1873                 if (r_refdef.extraupdate)
1874                         S_ExtraUpdate ();
1875
1876                 if (r_refdef.worldmodel && r_refdef.worldmodel->DrawSky)
1877                 {
1878                         r_refdef.worldmodel->DrawSky(r_refdef.worldentity);
1879                         if (r_timereport_active)
1880                                 R_TimeReport("worldsky");
1881                 }
1882
1883                 if (R_DrawBrushModelsSky() && r_timereport_active)
1884                         R_TimeReport("bmodelsky");
1885
1886                 if (r_refdef.worldmodel && r_refdef.worldmodel->Draw)
1887                 {
1888                         r_refdef.worldmodel->Draw(r_refdef.worldentity);
1889                         if (r_timereport_active)
1890                                 R_TimeReport("world");
1891                 }
1892         }
1893
1894         // don't let sound skip if going slow
1895         if (r_refdef.extraupdate)
1896                 S_ExtraUpdate ();
1897
1898         R_DrawModels();
1899         if (r_timereport_active)
1900                 R_TimeReport("models");
1901
1902         // don't let sound skip if going slow
1903         if (r_refdef.extraupdate)
1904                 S_ExtraUpdate ();
1905
1906         R_ShadowVolumeLighting(false);
1907         if (r_timereport_active)
1908                 R_TimeReport("rtlights");
1909
1910         // don't let sound skip if going slow
1911         if (r_refdef.extraupdate)
1912                 S_ExtraUpdate ();
1913
1914         if (cl.csqc_vidvars.drawworld)
1915         {
1916                 R_DrawLightningBeams();
1917                 if (r_timereport_active)
1918                         R_TimeReport("lightning");
1919
1920                 R_DrawParticles();
1921                 if (r_timereport_active)
1922                         R_TimeReport("particles");
1923
1924                 R_DrawExplosions();
1925                 if (r_timereport_active)
1926                         R_TimeReport("explosions");
1927         }
1928
1929         if (gl_support_fragment_shader)
1930         {
1931                 qglUseProgramObjectARB(0);CHECKGLERROR
1932         }
1933         VM_AddPolygonsToMeshQueue();
1934
1935         if (r_drawportals.integer)
1936         {
1937                 R_DrawPortals();
1938                 if (r_timereport_active)
1939                         R_TimeReport("portals");
1940         }
1941
1942         if (gl_support_fragment_shader)
1943         {
1944                 qglUseProgramObjectARB(0);CHECKGLERROR
1945         }
1946         R_MeshQueue_RenderTransparent();
1947         if (r_timereport_active)
1948                 R_TimeReport("drawtrans");
1949
1950         if (gl_support_fragment_shader)
1951         {
1952                 qglUseProgramObjectARB(0);CHECKGLERROR
1953         }
1954
1955         if (cl.csqc_vidvars.drawworld)
1956         {
1957                 R_DrawCoronas();
1958                 if (r_timereport_active)
1959                         R_TimeReport("coronas");
1960         }
1961
1962         // don't let sound skip if going slow
1963         if (r_refdef.extraupdate)
1964                 S_ExtraUpdate ();
1965
1966         CHECKGLERROR
1967         if (gl_support_fragment_shader)
1968         {
1969                 qglUseProgramObjectARB(0);CHECKGLERROR
1970         }
1971         qglPolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
1972         qglDisable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
1973 }
1974
1975 /*
1976 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
1977 {
1978         int i;
1979         float *v, *c, f1, f2, diff[3], vertex3f[8*3], color4f[8*4];
1980         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1981         GL_DepthMask(false);
1982         GL_DepthTest(true);
1983         R_Mesh_Matrix(&identitymatrix);
1984
1985         vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2];
1986         vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
1987         vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
1988         vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
1989         vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
1990         vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
1991         vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
1992         vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
1993         R_FillColors(color, 8, cr, cg, cb, ca);
1994         if (r_refdef.fogenabled)
1995         {
1996                 for (i = 0, v = vertex, c = color;i < 8;i++, v += 4, c += 4)
1997                 {
1998                         f2 = VERTEXFOGTABLE(VectorDistance(v, r_view.origin));
1999                         f1 = 1 - f2;
2000                         c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
2001                         c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
2002                         c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
2003                 }
2004         }
2005         R_Mesh_VertexPointer(vertex3f);
2006         R_Mesh_ColorPointer(color);
2007         R_Mesh_ResetTextureState();
2008         R_Mesh_Draw(8, 12);
2009 }
2010 */
2011
2012 int nomodelelements[24] =
2013 {
2014         5, 2, 0,
2015         5, 1, 2,
2016         5, 0, 3,
2017         5, 3, 1,
2018         0, 2, 4,
2019         2, 1, 4,
2020         3, 0, 4,
2021         1, 3, 4
2022 };
2023
2024 float nomodelvertex3f[6*3] =
2025 {
2026         -16,   0,   0,
2027          16,   0,   0,
2028           0, -16,   0,
2029           0,  16,   0,
2030           0,   0, -16,
2031           0,   0,  16
2032 };
2033
2034 float nomodelcolor4f[6*4] =
2035 {
2036         0.0f, 0.0f, 0.5f, 1.0f,
2037         0.0f, 0.0f, 0.5f, 1.0f,
2038         0.0f, 0.5f, 0.0f, 1.0f,
2039         0.0f, 0.5f, 0.0f, 1.0f,
2040         0.5f, 0.0f, 0.0f, 1.0f,
2041         0.5f, 0.0f, 0.0f, 1.0f
2042 };
2043
2044 void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
2045 {
2046         int i;
2047         float f1, f2, *c;
2048         float color4f[6*4];
2049         // this is only called once per entity so numsurfaces is always 1, and
2050         // surfacelist is always {0}, so this code does not handle batches
2051         R_Mesh_Matrix(&ent->matrix);
2052
2053         if (ent->flags & EF_ADDITIVE)
2054         {
2055                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2056                 GL_DepthMask(false);
2057         }
2058         else if (ent->alpha < 1)
2059         {
2060                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2061                 GL_DepthMask(false);
2062         }
2063         else
2064         {
2065                 GL_BlendFunc(GL_ONE, GL_ZERO);
2066                 GL_DepthMask(true);
2067         }
2068         GL_DepthTest(!(ent->effects & EF_NODEPTHTEST));
2069         R_Mesh_VertexPointer(nomodelvertex3f);
2070         if (r_refdef.fogenabled)
2071         {
2072                 vec3_t org;
2073                 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
2074                 R_Mesh_ColorPointer(color4f);
2075                 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
2076                 f2 = VERTEXFOGTABLE(VectorDistance(org, r_view.origin));
2077                 f1 = 1 - f2;
2078                 for (i = 0, c = color4f;i < 6;i++, c += 4)
2079                 {
2080                         c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
2081                         c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
2082                         c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
2083                         c[3] *= ent->alpha;
2084                 }
2085         }
2086         else if (ent->alpha != 1)
2087         {
2088                 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
2089                 R_Mesh_ColorPointer(color4f);
2090                 for (i = 0, c = color4f;i < 6;i++, c += 4)
2091                         c[3] *= ent->alpha;
2092         }
2093         else
2094                 R_Mesh_ColorPointer(nomodelcolor4f);
2095         R_Mesh_ResetTextureState();
2096         R_Mesh_Draw(0, 6, 8, nomodelelements);
2097 }
2098
2099 void R_DrawNoModel(entity_render_t *ent)
2100 {
2101         vec3_t org;
2102         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
2103         //if ((ent->effects & EF_ADDITIVE) || (ent->alpha < 1))
2104                 R_MeshQueue_AddTransparent(ent->effects & EF_NODEPTHTEST ? r_view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, r_shadow_rtlight);
2105         //else
2106         //      R_DrawNoModelCallback(ent, 0);
2107 }
2108
2109 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
2110 {
2111         vec3_t right1, right2, diff, normal;
2112
2113         VectorSubtract (org2, org1, normal);
2114
2115         // calculate 'right' vector for start
2116         VectorSubtract (r_view.origin, org1, diff);
2117         CrossProduct (normal, diff, right1);
2118         VectorNormalize (right1);
2119
2120         // calculate 'right' vector for end
2121         VectorSubtract (r_view.origin, org2, diff);
2122         CrossProduct (normal, diff, right2);
2123         VectorNormalize (right2);
2124
2125         vert[ 0] = org1[0] + width * right1[0];
2126         vert[ 1] = org1[1] + width * right1[1];
2127         vert[ 2] = org1[2] + width * right1[2];
2128         vert[ 3] = org1[0] - width * right1[0];
2129         vert[ 4] = org1[1] - width * right1[1];
2130         vert[ 5] = org1[2] - width * right1[2];
2131         vert[ 6] = org2[0] - width * right2[0];
2132         vert[ 7] = org2[1] - width * right2[1];
2133         vert[ 8] = org2[2] - width * right2[2];
2134         vert[ 9] = org2[0] + width * right2[0];
2135         vert[10] = org2[1] + width * right2[1];
2136         vert[11] = org2[2] + width * right2[2];
2137 }
2138
2139 float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
2140
2141 void R_DrawSprite(int blendfunc1, int blendfunc2, rtexture_t *texture, rtexture_t *fogtexture, 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)
2142 {
2143         float fog = 0.0f, ifog;
2144         float vertex3f[12];
2145
2146         if (r_refdef.fogenabled)
2147                 fog = VERTEXFOGTABLE(VectorDistance(origin, r_view.origin));
2148         ifog = 1 - fog;
2149
2150         R_Mesh_Matrix(&identitymatrix);
2151         GL_BlendFunc(blendfunc1, blendfunc2);
2152         GL_DepthMask(false);
2153         GL_DepthTest(!depthdisable);
2154
2155         vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
2156         vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
2157         vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
2158         vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
2159         vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
2160         vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
2161         vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
2162         vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
2163         vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
2164         vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
2165         vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
2166         vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
2167
2168         R_Mesh_VertexPointer(vertex3f);
2169         R_Mesh_ColorPointer(NULL);
2170         R_Mesh_ResetTextureState();
2171         R_Mesh_TexBind(0, R_GetTexture(texture));
2172         R_Mesh_TexCoordPointer(0, 2, spritetexcoord2f);
2173         // FIXME: fixed function path can't properly handle r_view.colorscale > 1
2174         GL_Color(cr * ifog * r_view.colorscale, cg * ifog * r_view.colorscale, cb * ifog * r_view.colorscale, ca);
2175         R_Mesh_Draw(0, 4, 2, polygonelements);
2176
2177         if (blendfunc2 == GL_ONE_MINUS_SRC_ALPHA)
2178         {
2179                 R_Mesh_TexBind(0, R_GetTexture(fogtexture));
2180                 GL_BlendFunc(blendfunc1, GL_ONE);
2181                 GL_Color(r_refdef.fogcolor[0] * fog * r_view.colorscale, r_refdef.fogcolor[1] * fog * r_view.colorscale, r_refdef.fogcolor[2] * fog * r_view.colorscale, ca);
2182                 R_Mesh_Draw(0, 4, 2, polygonelements);
2183         }
2184 }
2185
2186 int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
2187 {
2188         int i;
2189         float *vertex3f;
2190         float v[3];
2191         VectorSet(v, x, y, z);
2192         for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
2193                 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
2194                         break;
2195         if (i == mesh->numvertices)
2196         {
2197                 if (mesh->numvertices < mesh->maxvertices)
2198                 {
2199                         VectorCopy(v, vertex3f);
2200                         mesh->numvertices++;
2201                 }
2202                 return mesh->numvertices;
2203         }
2204         else
2205                 return i;
2206 }
2207
2208 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
2209 {
2210         int i;
2211         int *e, element[3];
2212         element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
2213         element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
2214         e = mesh->element3i + mesh->numtriangles * 3;
2215         for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
2216         {
2217                 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
2218                 if (mesh->numtriangles < mesh->maxtriangles)
2219                 {
2220                         *e++ = element[0];
2221                         *e++ = element[1];
2222                         *e++ = element[2];
2223                         mesh->numtriangles++;
2224                 }
2225                 element[1] = element[2];
2226         }
2227 }
2228
2229 void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
2230 {
2231         int i;
2232         int *e, element[3];
2233         element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
2234         element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
2235         e = mesh->element3i + mesh->numtriangles * 3;
2236         for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
2237         {
2238                 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
2239                 if (mesh->numtriangles < mesh->maxtriangles)
2240                 {
2241                         *e++ = element[0];
2242                         *e++ = element[1];
2243                         *e++ = element[2];
2244                         mesh->numtriangles++;
2245                 }
2246                 element[1] = element[2];
2247         }
2248 }
2249
2250 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
2251 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
2252 {
2253         int planenum, planenum2;
2254         int w;
2255         int tempnumpoints;
2256         mplane_t *plane, *plane2;
2257         double maxdist;
2258         double temppoints[2][256*3];
2259         // figure out how large a bounding box we need to properly compute this brush
2260         maxdist = 0;
2261         for (w = 0;w < numplanes;w++)
2262                 maxdist = max(maxdist, planes[w].dist);
2263         // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
2264         maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
2265         for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
2266         {
2267                 w = 0;
2268                 tempnumpoints = 4;
2269                 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
2270                 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
2271                 {
2272                         if (planenum2 == planenum)
2273                                 continue;
2274                         PolygonD_Divide(tempnumpoints, temppoints[w], plane2->normal[0], plane2->normal[1], plane2->normal[2], plane2->dist, R_MESH_PLANE_DIST_EPSILON, 0, NULL, NULL, 256, temppoints[!w], &tempnumpoints, NULL);
2275                         w = !w;
2276                 }
2277                 if (tempnumpoints < 3)
2278                         continue;
2279                 // generate elements forming a triangle fan for this polygon
2280                 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
2281         }
2282 }
2283
2284 static void R_DrawCollisionBrush(const colbrushf_t *brush)
2285 {
2286         int i;
2287         R_Mesh_VertexPointer(brush->points->v);
2288         i = (int)(((size_t)brush) / sizeof(colbrushf_t));
2289         GL_Color((i & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 5) & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 10) & 31) * (1.0f / 32.0f) * r_view.colorscale, 0.2f);
2290         GL_LockArrays(0, brush->numpoints);
2291         R_Mesh_Draw(0, brush->numpoints, brush->numtriangles, brush->elements);
2292         GL_LockArrays(0, 0);
2293 }
2294
2295 static void R_DrawCollisionSurface(const entity_render_t *ent, const msurface_t *surface)
2296 {
2297         int i;
2298         if (!surface->num_collisiontriangles)
2299                 return;
2300         R_Mesh_VertexPointer(surface->data_collisionvertex3f);
2301         i = (int)(((size_t)surface) / sizeof(msurface_t));
2302         GL_Color((i & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 5) & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 10) & 31) * (1.0f / 32.0f) * r_view.colorscale, 0.2f);
2303         GL_LockArrays(0, surface->num_collisionvertices);
2304         R_Mesh_Draw(0, surface->num_collisionvertices, surface->num_collisiontriangles, surface->data_collisionelement3i);
2305         GL_LockArrays(0, 0);
2306 }
2307
2308 static void R_Texture_AddLayer(texture_t *t, qboolean depthmask, int blendfunc1, int blendfunc2, texturelayertype_t type, rtexture_t *texture, const matrix4x4_t *matrix, float r, float g, float b, float a)
2309 {
2310         texturelayer_t *layer;
2311         layer = t->currentlayers + t->currentnumlayers++;
2312         layer->type = type;
2313         layer->depthmask = depthmask;
2314         layer->blendfunc1 = blendfunc1;
2315         layer->blendfunc2 = blendfunc2;
2316         layer->texture = texture;
2317         layer->texmatrix = *matrix;
2318         layer->color[0] = r * r_view.colorscale;
2319         layer->color[1] = g * r_view.colorscale;
2320         layer->color[2] = b * r_view.colorscale;
2321         layer->color[3] = a;
2322 }
2323
2324 void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
2325 {
2326         // FIXME: identify models using a better check than ent->model->brush.shadowmesh
2327         //int lightmode = ((ent->effects & EF_FULLBRIGHT) || ent->model->brush.shadowmesh) ? 0 : 2;
2328
2329         {
2330                 texture_t *texture = t;
2331                 model_t *model = ent->model;
2332                 int s = ent->skinnum;
2333                 if ((unsigned int)s >= (unsigned int)model->numskins)
2334                         s = 0;
2335                 if (model->skinscenes)
2336                 {
2337                         if (model->skinscenes[s].framecount > 1)
2338                                 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
2339                         else
2340                                 s = model->skinscenes[s].firstframe;
2341                 }
2342                 if (s > 0)
2343                         t = t + s * model->num_surfaces;
2344                 if (t->animated)
2345                 {
2346                         // use an alternate animation if the entity's frame is not 0,
2347                         // and only if the texture has an alternate animation
2348                         if (ent->frame != 0 && t->anim_total[1])
2349                                 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[1]) : 0];
2350                         else
2351                                 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[0]) : 0];
2352                 }
2353                 texture->currentframe = t;
2354         }
2355
2356         t->currentmaterialflags = t->basematerialflags;
2357         t->currentalpha = ent->alpha;
2358         if (t->basematerialflags & MATERIALFLAG_WATERALPHA)
2359                 t->currentalpha *= r_wateralpha.value;
2360         if (!(ent->flags & RENDER_LIGHT))
2361                 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
2362         if (ent->effects & EF_ADDITIVE)
2363                 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT;
2364         else if (t->currentalpha < 1)
2365                 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT;
2366         if (ent->effects & EF_NODEPTHTEST)
2367                 t->currentmaterialflags |= MATERIALFLAG_NODEPTHTEST;
2368         if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
2369                 t->currenttexmatrix = r_waterscrollmatrix;
2370         else
2371                 t->currenttexmatrix = identitymatrix;
2372
2373         t->colormapping = VectorLength2(ent->colormap_pantscolor) + VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f);
2374         t->basetexture = (!t->colormapping && t->skin.merged) ? t->skin.merged : t->skin.base;
2375         t->glosstexture = r_texture_white;
2376         t->specularpower = 8;
2377         t->specularscale = 0;
2378         if (r_shadow_gloss.integer > 0)
2379         {
2380                 if (t->skin.gloss)
2381                 {
2382                         if (r_shadow_glossintensity.value > 0)
2383                         {
2384                                 t->glosstexture = t->skin.gloss;
2385                                 t->specularscale = r_shadow_glossintensity.value;
2386                         }
2387                 }
2388                 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
2389                         t->specularscale = r_shadow_gloss2intensity.value;
2390         }
2391
2392         t->currentnumlayers = 0;
2393         if (!(t->currentmaterialflags & MATERIALFLAG_NODRAW))
2394         {
2395                 if (gl_lightmaps.integer)
2396                         R_Texture_AddLayer(t, true, GL_ONE, GL_ZERO, TEXTURELAYERTYPE_LITTEXTURE, r_texture_white, &identitymatrix, 1, 1, 1, 1);
2397                 else if (!(t->currentmaterialflags & MATERIALFLAG_SKY))
2398                 {
2399                         int blendfunc1, blendfunc2, depthmask;
2400                         if (t->currentmaterialflags & MATERIALFLAG_ADD)
2401                         {
2402                                 blendfunc1 = GL_SRC_ALPHA;
2403                                 blendfunc2 = GL_ONE;
2404                         }
2405                         else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
2406                         {
2407                                 blendfunc1 = GL_SRC_ALPHA;
2408                                 blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
2409                         }
2410                         else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
2411                         {
2412                                 blendfunc1 = t->customblendfunc[0];
2413                                 blendfunc2 = t->customblendfunc[1];
2414                         }
2415                         else
2416                         {
2417                                 blendfunc1 = GL_ONE;
2418                                 blendfunc2 = GL_ZERO;
2419                         }
2420                         depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
2421                         if (t->currentmaterialflags & (MATERIALFLAG_WATER | MATERIALFLAG_WALL))
2422                         {
2423                                 rtexture_t *currentbasetexture;
2424                                 int layerflags = 0;
2425                                 if (r_refdef.fogenabled && (t->currentmaterialflags & MATERIALFLAG_BLENDED))
2426                                         layerflags |= TEXTURELAYERFLAG_FOGDARKEN;
2427                                 currentbasetexture = (VectorLength2(ent->colormap_pantscolor) + VectorLength2(ent->colormap_shirtcolor) < (1.0f / 1048576.0f) && t->skin.merged) ? t->skin.merged : t->skin.base;
2428                                 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
2429                                 {
2430                                         // fullbright is not affected by r_refdef.lightmapintensity
2431                                         R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_TEXTURE, currentbasetexture, &t->currenttexmatrix, ent->colormod[0], ent->colormod[1], ent->colormod[2], t->currentalpha);
2432                                         if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->skin.pants)
2433                                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->skin.pants, &t->currenttexmatrix, ent->colormap_pantscolor[0] * ent->colormod[0], ent->colormap_pantscolor[1] * ent->colormod[1], ent->colormap_pantscolor[2] * ent->colormod[2], t->currentalpha);
2434                                         if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->skin.shirt)
2435                                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->skin.shirt, &t->currenttexmatrix, ent->colormap_shirtcolor[0] * ent->colormod[0], ent->colormap_shirtcolor[1] * ent->colormod[1], ent->colormap_shirtcolor[2] * ent->colormod[2], t->currentalpha);
2436                                 }
2437                                 else
2438                                 {
2439                                         float colorscale;
2440                                         colorscale = 2;
2441                                         // q3bsp has no lightmap updates, so the lightstylevalue that
2442                                         // would normally be baked into the lightmap must be
2443                                         // applied to the color
2444                                         if (ent->model->type == mod_brushq3)
2445                                                 colorscale *= r_refdef.lightstylevalue[0] * (1.0f / 256.0f);
2446                                         colorscale *= r_refdef.lightmapintensity;
2447                                         R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_LITTEXTURE, currentbasetexture, &t->currenttexmatrix, ent->colormod[0] * colorscale, ent->colormod[1] * colorscale, ent->colormod[2] * colorscale, t->currentalpha);
2448                                         if (r_ambient.value >= (1.0f/64.0f))
2449                                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, currentbasetexture, &t->currenttexmatrix, ent->colormod[0] * r_ambient.value * (1.0f / 64.0f), ent->colormod[1] * r_ambient.value * (1.0f / 64.0f), ent->colormod[2] * r_ambient.value * (1.0f / 64.0f), t->currentalpha);
2450                                         if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->skin.pants)
2451                                         {
2452                                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->skin.pants, &t->currenttexmatrix, ent->colormap_pantscolor[0] * ent->colormod[0] * colorscale, ent->colormap_pantscolor[1] * ent->colormod[1] * colorscale, ent->colormap_pantscolor[2]  * ent->colormod[2] * colorscale, t->currentalpha);
2453                                                 if (r_ambient.value >= (1.0f/64.0f))
2454                                                         R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->skin.pants, &t->currenttexmatrix, ent->colormap_pantscolor[0] * ent->colormod[0] * r_ambient.value * (1.0f / 64.0f), ent->colormap_pantscolor[1] * ent->colormod[1] * r_ambient.value * (1.0f / 64.0f), ent->colormap_pantscolor[2] * ent->colormod[2] * r_ambient.value * (1.0f / 64.0f), t->currentalpha);
2455                                         }
2456                                         if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->skin.shirt)
2457                                         {
2458                                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->skin.shirt, &t->currenttexmatrix, ent->colormap_shirtcolor[0] * ent->colormod[0] * colorscale, ent->colormap_shirtcolor[1] * ent->colormod[1] * colorscale, ent->colormap_shirtcolor[2] * ent->colormod[2] * colorscale, t->currentalpha);
2459                                                 if (r_ambient.value >= (1.0f/64.0f))
2460                                                         R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->skin.shirt, &t->currenttexmatrix, ent->colormap_shirtcolor[0] * ent->colormod[0] * r_ambient.value * (1.0f / 64.0f), ent->colormap_shirtcolor[1] * ent->colormod[1] * r_ambient.value * (1.0f / 64.0f), ent->colormap_shirtcolor[2] * ent->colormod[2] * r_ambient.value * (1.0f / 64.0f), t->currentalpha);
2461                                         }
2462                                 }
2463                                 if (t->skin.glow != NULL)
2464                                         R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->skin.glow, &t->currenttexmatrix, r_hdr_glowintensity.value, r_hdr_glowintensity.value, r_hdr_glowintensity.value, t->currentalpha);
2465                                 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
2466                                 {
2467                                         // if this is opaque use alpha blend which will darken the earlier
2468                                         // passes cheaply.
2469                                         //
2470                                         // if this is an alpha blended material, all the earlier passes
2471                                         // were darkened by fog already, so we only need to add the fog
2472                                         // color ontop through the fog mask texture
2473                                         //
2474                                         // if this is an additive blended material, all the earlier passes
2475                                         // were darkened by fog already, and we should not add fog color
2476                                         // (because the background was not darkened, there is no fog color
2477                                         // that was lost behind it).
2478                                         R_Texture_AddLayer(t, false, GL_SRC_ALPHA, (t->currentmaterialflags & MATERIALFLAG_BLENDED) ? GL_ONE : GL_ONE_MINUS_SRC_ALPHA, TEXTURELAYERTYPE_FOG, t->skin.fog, &identitymatrix, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], t->currentalpha);
2479                                 }
2480                         }
2481                 }
2482         }
2483 }
2484
2485 void R_UpdateAllTextureInfo(entity_render_t *ent)
2486 {
2487         int i;
2488         if (ent->model)
2489                 for (i = 0;i < ent->model->num_textures;i++)
2490                         R_UpdateTextureInfo(ent, ent->model->data_textures + i);
2491 }
2492
2493 int rsurface_array_size = 0;
2494 float *rsurface_array_modelvertex3f = NULL;
2495 float *rsurface_array_modelsvector3f = NULL;
2496 float *rsurface_array_modeltvector3f = NULL;
2497 float *rsurface_array_modelnormal3f = NULL;
2498 float *rsurface_array_deformedvertex3f = NULL;
2499 float *rsurface_array_deformedsvector3f = NULL;
2500 float *rsurface_array_deformedtvector3f = NULL;
2501 float *rsurface_array_deformednormal3f = NULL;
2502 float *rsurface_array_color4f = NULL;
2503 float *rsurface_array_texcoord3f = NULL;
2504
2505 void R_Mesh_ResizeArrays(int newvertices)
2506 {
2507         float *base;
2508         if (rsurface_array_size >= newvertices)
2509                 return;
2510         if (rsurface_array_modelvertex3f)
2511                 Mem_Free(rsurface_array_modelvertex3f);
2512         rsurface_array_size = (newvertices + 1023) & ~1023;
2513         base = (float *)Mem_Alloc(r_main_mempool, rsurface_array_size * sizeof(float[31]));
2514         rsurface_array_modelvertex3f     = base + rsurface_array_size * 0;
2515         rsurface_array_modelsvector3f    = base + rsurface_array_size * 3;
2516         rsurface_array_modeltvector3f    = base + rsurface_array_size * 6;
2517         rsurface_array_modelnormal3f     = base + rsurface_array_size * 9;
2518         rsurface_array_deformedvertex3f  = base + rsurface_array_size * 12;
2519         rsurface_array_deformedsvector3f = base + rsurface_array_size * 15;
2520         rsurface_array_deformedtvector3f = base + rsurface_array_size * 18;
2521         rsurface_array_deformednormal3f  = base + rsurface_array_size * 21;
2522         rsurface_array_texcoord3f        = base + rsurface_array_size * 24;
2523         rsurface_array_color4f           = base + rsurface_array_size * 27;
2524 }
2525
2526 float *rsurface_modelvertex3f;
2527 float *rsurface_modelsvector3f;
2528 float *rsurface_modeltvector3f;
2529 float *rsurface_modelnormal3f;
2530 float *rsurface_vertex3f;
2531 float *rsurface_svector3f;
2532 float *rsurface_tvector3f;
2533 float *rsurface_normal3f;
2534 float *rsurface_lightmapcolor4f;
2535 vec3_t rsurface_modelorg;
2536 qboolean rsurface_generatedvertex;
2537 const entity_render_t *rsurface_entity;
2538 const model_t *rsurface_model;
2539 texture_t *rsurface_texture;
2540 rtexture_t *rsurface_lightmaptexture;
2541 rsurfmode_t rsurface_mode;
2542 texture_t *rsurface_glsl_texture;
2543 qboolean rsurface_glsl_uselightmap;
2544
2545 void RSurf_ActiveEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
2546 {
2547         Matrix4x4_Transform(&ent->inversematrix, r_view.origin, rsurface_modelorg);
2548         rsurface_entity = ent;
2549         rsurface_model = ent->model;
2550         if (rsurface_array_size < rsurface_model->surfmesh.num_vertices)
2551                 R_Mesh_ResizeArrays(rsurface_model->surfmesh.num_vertices);
2552         R_Mesh_Matrix(&ent->matrix);
2553         Matrix4x4_Transform(&ent->inversematrix, r_view.origin, rsurface_modelorg);
2554         if ((rsurface_entity->frameblend[0].lerp != 1 || rsurface_entity->frameblend[0].frame != 0) && rsurface_model->surfmesh.isanimated)
2555         {
2556                 if (wanttangents)
2557                 {
2558                         rsurface_modelvertex3f = rsurface_array_modelvertex3f;
2559                         rsurface_modelsvector3f = rsurface_array_modelsvector3f;
2560                         rsurface_modeltvector3f = rsurface_array_modeltvector3f;
2561                         rsurface_modelnormal3f = rsurface_array_modelnormal3f;
2562                         Mod_Alias_GetMesh_Vertices(rsurface_model, rsurface_entity->frameblend, rsurface_array_modelvertex3f, rsurface_array_modelnormal3f, rsurface_array_modelsvector3f, rsurface_array_modeltvector3f);
2563                 }
2564                 else if (wantnormals)
2565                 {
2566                         rsurface_modelvertex3f = rsurface_array_modelvertex3f;
2567                         rsurface_modelsvector3f = NULL;
2568                         rsurface_modeltvector3f = NULL;
2569                         rsurface_modelnormal3f = rsurface_array_modelnormal3f;
2570                         Mod_Alias_GetMesh_Vertices(rsurface_model, rsurface_entity->frameblend, rsurface_array_modelvertex3f, rsurface_array_modelnormal3f, NULL, NULL);
2571                 }
2572                 else
2573                 {
2574                         rsurface_modelvertex3f = rsurface_array_modelvertex3f;
2575                         rsurface_modelsvector3f = NULL;
2576                         rsurface_modeltvector3f = NULL;
2577                         rsurface_modelnormal3f = NULL;
2578                         Mod_Alias_GetMesh_Vertices(rsurface_model, rsurface_entity->frameblend, rsurface_array_modelvertex3f, NULL, NULL, NULL);
2579                 }
2580                 rsurface_generatedvertex = true;
2581         }
2582         else
2583         {
2584                 rsurface_modelvertex3f  = rsurface_model->surfmesh.data_vertex3f;
2585                 rsurface_modelsvector3f = rsurface_model->surfmesh.data_svector3f;
2586                 rsurface_modeltvector3f = rsurface_model->surfmesh.data_tvector3f;
2587                 rsurface_modelnormal3f  = rsurface_model->surfmesh.data_normal3f;
2588                 rsurface_generatedvertex = false;
2589         }
2590         rsurface_vertex3f  = rsurface_modelvertex3f;
2591         rsurface_svector3f = rsurface_modelsvector3f;
2592         rsurface_tvector3f = rsurface_modeltvector3f;
2593         rsurface_normal3f  = rsurface_modelnormal3f;
2594         rsurface_mode = RSURFMODE_NONE;
2595         rsurface_lightmaptexture = NULL;
2596         rsurface_texture = NULL;
2597         rsurface_glsl_texture = NULL;
2598         rsurface_glsl_uselightmap = false;
2599 }
2600
2601 void RSurf_CleanUp(void)
2602 {
2603         CHECKGLERROR
2604         if (rsurface_mode == RSURFMODE_GLSL)
2605         {
2606                 qglUseProgramObjectARB(0);CHECKGLERROR
2607         }
2608         GL_AlphaTest(false);
2609         rsurface_mode = RSURFMODE_NONE;
2610         rsurface_lightmaptexture = NULL;
2611         rsurface_texture = NULL;
2612         rsurface_glsl_texture = NULL;
2613         rsurface_glsl_uselightmap = false;
2614 }
2615
2616 void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, msurface_t **texturesurfacelist)
2617 {
2618         // if vertices are dynamic (animated models), generate them into the temporary rsurface_array_model* arrays and point rsurface_model* at them instead of the static data from the model itself
2619         if (rsurface_generatedvertex)
2620         {
2621                 if (rsurface_texture->textureflags & (Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2))
2622                         generatetangents = true;
2623                 if (generatetangents)
2624                         generatenormals = true;
2625                 if (generatenormals && !rsurface_modelnormal3f)
2626                 {
2627                         rsurface_normal3f = rsurface_modelnormal3f = rsurface_array_modelnormal3f;
2628                         Mod_BuildNormals(0, rsurface_model->surfmesh.num_vertices, rsurface_model->surfmesh.num_triangles, rsurface_modelvertex3f, rsurface_model->surfmesh.data_element3i, rsurface_array_modelnormal3f, r_smoothnormals_areaweighting.integer);
2629                 }
2630                 if (generatetangents && !rsurface_modelsvector3f)
2631                 {
2632                         rsurface_svector3f = rsurface_modelsvector3f = rsurface_array_modelsvector3f;
2633                         rsurface_tvector3f = rsurface_modeltvector3f = rsurface_array_modeltvector3f;
2634                         Mod_BuildTextureVectorsFromNormals(0, rsurface_model->surfmesh.num_vertices, rsurface_model->surfmesh.num_triangles, rsurface_modelvertex3f, rsurface_model->surfmesh.data_texcoordtexture2f, rsurface_modelnormal3f, rsurface_model->surfmesh.data_element3i, rsurface_array_modelsvector3f, rsurface_array_modeltvector3f, r_smoothnormals_areaweighting.integer);
2635                 }
2636         }
2637         // if vertices are deformed (sprite flares and things in maps, possibly water waves, bulges and other deformations), generate them into rsurface_deform* arrays from whatever the rsurface_model* array pointers point to (may be static model data or generated data for an animated model)
2638         if (rsurface_texture->textureflags & (Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2))
2639         {
2640                 int texturesurfaceindex;
2641                 float center[3], forward[3], right[3], up[3], v[4][3];
2642                 matrix4x4_t matrix1, imatrix1;
2643                 Matrix4x4_Transform(&rsurface_entity->inversematrix, r_view.forward, forward);
2644                 Matrix4x4_Transform(&rsurface_entity->inversematrix, r_view.right, right);
2645                 Matrix4x4_Transform(&rsurface_entity->inversematrix, r_view.up, up);
2646                 // make deformed versions of only the model vertices used by the specified surfaces
2647                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2648                 {
2649                         int i, j;
2650                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2651                         // a single autosprite surface can contain multiple sprites...
2652                         for (j = 0;j < surface->num_vertices - 3;j += 4)
2653                         {
2654                                 VectorClear(center);
2655                                 for (i = 0;i < 4;i++)
2656                                         VectorAdd(center, (rsurface_modelvertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
2657                                 VectorScale(center, 0.25f, center);
2658                                 if (rsurface_texture->textureflags & Q3TEXTUREFLAG_AUTOSPRITE2)
2659                                 {
2660                                         forward[0] = rsurface_modelorg[0] - center[0];
2661                                         forward[1] = rsurface_modelorg[1] - center[1];
2662                                         forward[2] = 0;
2663                                         VectorNormalize(forward);
2664                                         right[0] = forward[1];
2665                                         right[1] = -forward[0];
2666                                         right[2] = 0;
2667                                         VectorSet(up, 0, 0, 1);
2668                                 }
2669                                 // FIXME: calculate vectors from triangle edges instead of using texture vectors as an easy way out?
2670                                 Matrix4x4_FromVectors(&matrix1, (rsurface_modelnormal3f + 3 * surface->num_firstvertex) + j*3, (rsurface_modelsvector3f + 3 * surface->num_firstvertex) + j*3, (rsurface_modeltvector3f + 3 * surface->num_firstvertex) + j*3, center);
2671                                 Matrix4x4_Invert_Simple(&imatrix1, &matrix1);
2672                                 for (i = 0;i < 4;i++)
2673                                         Matrix4x4_Transform(&imatrix1, (rsurface_modelvertex3f + 3 * surface->num_firstvertex) + (j+i)*3, v[i]);
2674                                 for (i = 0;i < 4;i++)
2675                                         VectorMAMAMAM(1, center, v[i][0], forward, v[i][1], right, v[i][2], up, rsurface_array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
2676                         }
2677                         Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface_modelvertex3f, rsurface_model->surfmesh.data_element3i + surface->num_firsttriangle * 3, rsurface_array_deformednormal3f, r_smoothnormals_areaweighting.integer);
2678                         Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface_modelvertex3f, rsurface_model->surfmesh.data_texcoordtexture2f, rsurface_array_deformednormal3f, rsurface_model->surfmesh.data_element3i + surface->num_firsttriangle * 3, rsurface_array_deformedsvector3f, rsurface_array_deformedtvector3f, r_smoothnormals_areaweighting.integer);
2679                 }
2680                 rsurface_vertex3f = rsurface_array_deformedvertex3f;
2681                 rsurface_svector3f = rsurface_array_deformedsvector3f;
2682                 rsurface_tvector3f = rsurface_array_deformedtvector3f;
2683                 rsurface_normal3f = rsurface_array_deformednormal3f;
2684         }
2685         R_Mesh_VertexPointer(rsurface_vertex3f);
2686 }
2687
2688 void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacelist)
2689 {
2690         int texturesurfaceindex;
2691         const msurface_t *surface = texturesurfacelist[0];
2692         int firstvertex = surface->num_firstvertex;
2693         int endvertex = surface->num_firstvertex + surface->num_vertices;
2694         if (texturenumsurfaces == 1)
2695         {
2696                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2697                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
2698         }
2699         else if (r_batchmode.integer == 2)
2700         {
2701                 #define MAXBATCHTRIANGLES 4096
2702                 int batchtriangles = 0;
2703                 int batchelements[MAXBATCHTRIANGLES*3];
2704                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2705                 {
2706                         surface = texturesurfacelist[texturesurfaceindex];
2707                         if (surface->num_triangles >= 256 || (batchtriangles == 0 && texturesurfaceindex + 1 >= texturenumsurfaces))
2708                         {
2709                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
2710                                 continue;
2711                         }
2712                         if (batchtriangles + surface->num_triangles > MAXBATCHTRIANGLES)
2713                         {
2714                                 R_Mesh_Draw(firstvertex, endvertex - firstvertex, batchtriangles, batchelements);
2715                                 batchtriangles = 0;
2716                                 firstvertex = surface->num_firstvertex;
2717                                 endvertex = surface->num_firstvertex + surface->num_vertices;
2718                         }
2719                         else
2720                         {
2721                                 firstvertex = min(firstvertex, surface->num_firstvertex);
2722                                 endvertex = max(endvertex, surface->num_firstvertex + surface->num_vertices);
2723                         }
2724                         memcpy(batchelements + batchtriangles * 3, rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
2725                         batchtriangles += surface->num_triangles;
2726                 }
2727                 if (batchtriangles)
2728                         R_Mesh_Draw(firstvertex, endvertex - firstvertex, batchtriangles, batchelements);
2729         }
2730         else if (r_batchmode.integer == 1)
2731         {
2732                 int firsttriangle = 0;
2733                 int endtriangle = -1;
2734                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2735                 {
2736                         surface = texturesurfacelist[texturesurfaceindex];
2737                         if (surface->num_firsttriangle != endtriangle)
2738                         {
2739                                 if (endtriangle > firsttriangle)
2740                                 {
2741                                         GL_LockArrays(firstvertex, endvertex - firstvertex);
2742                                         R_Mesh_Draw(firstvertex, endvertex - firstvertex, endtriangle - firsttriangle, (rsurface_model->surfmesh.data_element3i + 3 * firsttriangle));
2743                                 }
2744                                 firstvertex = surface->num_firstvertex;
2745                                 endvertex = surface->num_firstvertex + surface->num_vertices;
2746                                 firsttriangle = surface->num_firsttriangle;
2747                         }
2748                         else
2749                         {
2750                                 firstvertex = min(firstvertex, surface->num_firstvertex);
2751                                 endvertex = max(endvertex, surface->num_firstvertex + surface->num_vertices);
2752                         }
2753                         endtriangle = surface->num_firsttriangle + surface->num_triangles;
2754                 }
2755                 if (endtriangle > firsttriangle)
2756                 {
2757                         GL_LockArrays(firstvertex, endvertex - firstvertex);
2758                         R_Mesh_Draw(firstvertex, endvertex - firstvertex, endtriangle - firsttriangle, (rsurface_model->surfmesh.data_element3i + 3 * firsttriangle));
2759                 }
2760         }
2761         else
2762         {
2763                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2764                 {
2765                         surface = texturesurfacelist[texturesurfaceindex];
2766                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2767                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
2768                 }
2769         }
2770 }
2771
2772 static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
2773 {
2774         int texturesurfaceindex;
2775         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2776         {
2777                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2778                 int k = (int)(((size_t)surface) / sizeof(msurface_t));
2779                 GL_Color((k & 15) * (1.0f / 16.0f) * r_view.colorscale, ((k >> 4) & 15) * (1.0f / 16.0f) * r_view.colorscale, ((k >> 8) & 15) * (1.0f / 16.0f) * r_view.colorscale, 0.2f);
2780                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2781                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
2782         }
2783 }
2784
2785 static void RSurf_DrawBatch_Lightmap(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, int lightmode, qboolean applycolor, qboolean applyfog)
2786 {
2787         int texturesurfaceindex;
2788         int i;
2789         float f;
2790         float *v, *c, *c2;
2791         // TODO: optimize
2792         if (lightmode >= 2)
2793         {
2794                 // model lighting
2795                 vec3_t ambientcolor;
2796                 vec3_t diffusecolor;
2797                 vec3_t lightdir;
2798                 VectorCopy(rsurface_entity->modellight_lightdir, lightdir);
2799                 ambientcolor[0] = rsurface_entity->modellight_ambient[0] * r * 0.5f;
2800                 ambientcolor[1] = rsurface_entity->modellight_ambient[1] * g * 0.5f;
2801                 ambientcolor[2] = rsurface_entity->modellight_ambient[2] * b * 0.5f;
2802                 diffusecolor[0] = rsurface_entity->modellight_diffuse[0] * r * 0.5f;
2803                 diffusecolor[1] = rsurface_entity->modellight_diffuse[1] * g * 0.5f;
2804                 diffusecolor[2] = rsurface_entity->modellight_diffuse[2] * b * 0.5f;
2805                 if (VectorLength2(diffusecolor) > 0)
2806                 {
2807                         // generate color arrays for the surfaces in this list
2808                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2809                         {
2810                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2811                                 int numverts = surface->num_vertices;
2812                                 v = rsurface_vertex3f + 3 * surface->num_firstvertex;
2813                                 c2 = rsurface_normal3f + 3 * surface->num_firstvertex;
2814                                 c = rsurface_array_color4f + 4 * surface->num_firstvertex;
2815                                 // q3-style directional shading
2816                                 for (i = 0;i < numverts;i++, v += 3, c2 += 3, c += 4)
2817                                 {
2818                                         if ((f = DotProduct(c2, lightdir)) > 0)
2819                                                 VectorMA(ambientcolor, f, diffusecolor, c);
2820                                         else
2821                                                 VectorCopy(ambientcolor, c);
2822                                         c[3] = a;
2823                                 }
2824                         }
2825                         r = 1;
2826                         g = 1;
2827                         b = 1;
2828                         a = 1;
2829                         applycolor = false;
2830                         rsurface_lightmapcolor4f = rsurface_array_color4f;
2831                 }
2832                 else
2833                 {
2834                         r = ambientcolor[0];
2835                         g = ambientcolor[1];
2836                         b = ambientcolor[2];
2837                         rsurface_lightmapcolor4f = NULL;
2838                 }
2839         }
2840         else if (lightmode >= 1 || !rsurface_lightmaptexture)
2841         {
2842                 if (texturesurfacelist[0]->lightmapinfo && texturesurfacelist[0]->lightmapinfo->stainsamples)
2843                 {
2844                         // generate color arrays for the surfaces in this list
2845                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2846                         {
2847                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2848                                 for (i = 0, c = rsurface_array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
2849                                 {
2850                                         if (surface->lightmapinfo->samples)
2851                                         {
2852                                                 const unsigned char *lm = surface->lightmapinfo->samples + (rsurface_model->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i];
2853                                                 float scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
2854                                                 VectorScale(lm, scale, c);
2855                                                 if (surface->lightmapinfo->styles[1] != 255)
2856                                                 {
2857                                                         int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
2858                                                         lm += size3;
2859                                                         scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
2860                                                         VectorMA(c, scale, lm, c);
2861                                                         if (surface->lightmapinfo->styles[2] != 255)
2862                                                         {
2863                                                                 lm += size3;
2864                                                                 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
2865                                                                 VectorMA(c, scale, lm, c);
2866                                                                 if (surface->lightmapinfo->styles[3] != 255)
2867                                                                 {
2868                                                                         lm += size3;
2869                                                                         scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
2870                                                                         VectorMA(c, scale, lm, c);
2871                                                                 }
2872                                                         }
2873                                                 }
2874                                         }
2875                                         else
2876                                                 VectorClear(c);
2877                                         c[3] = 1;
2878                                 }
2879                         }
2880                         rsurface_lightmapcolor4f = rsurface_array_color4f;
2881                 }
2882                 else
2883                         rsurface_lightmapcolor4f = rsurface_model->surfmesh.data_lightmapcolor4f;
2884         }
2885         else
2886         {
2887                 // just lightmap it
2888                 rsurface_lightmapcolor4f = NULL;
2889         }
2890         if (applyfog)
2891         {
2892                 if (rsurface_lightmapcolor4f)
2893                 {
2894                         // generate color arrays for the surfaces in this list
2895                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2896                         {
2897                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2898                                 for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c = (rsurface_lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4, c2 += 4)
2899                                 {
2900                                         f = 1 - VERTEXFOGTABLE(VectorDistance(v, rsurface_modelorg));
2901                                         c2[0] = c[0] * f;
2902                                         c2[1] = c[1] * f;
2903                                         c2[2] = c[2] * f;
2904                                         c2[3] = c[3];
2905                                 }
2906                         }
2907                 }
2908                 else
2909                 {
2910                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2911                         {
2912                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2913                                 for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c2 = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c2 += 4)
2914                                 {
2915                                         f = 1 - VERTEXFOGTABLE(VectorDistance(v, rsurface_modelorg));
2916                                         c2[0] = f;
2917                                         c2[1] = f;
2918                                         c2[2] = f;
2919                                         c2[3] = 1;
2920                                 }
2921                         }
2922                 }
2923                 rsurface_lightmapcolor4f = rsurface_array_color4f;
2924         }
2925         if (applycolor && rsurface_lightmapcolor4f)
2926         {
2927                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2928                 {
2929                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2930                         for (i = 0, c = (rsurface_lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, c += 4, c2 += 4)
2931                         {
2932                                 c2[0] = c[0] * r;
2933                                 c2[1] = c[1] * g;
2934                                 c2[2] = c[2] * b;
2935                                 c2[3] = c[3] * a;
2936                         }
2937                 }
2938                 rsurface_lightmapcolor4f = rsurface_array_color4f;
2939         }
2940         R_Mesh_ColorPointer(rsurface_lightmapcolor4f);
2941         GL_Color(r, g, b, a);
2942         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
2943 }
2944
2945 static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
2946 {
2947         if (rsurface_mode != RSURFMODE_SHOWSURFACES)
2948         {
2949                 rsurface_mode = RSURFMODE_SHOWSURFACES;
2950                 GL_DepthMask(true);
2951                 GL_BlendFunc(GL_ONE, GL_ZERO);
2952                 R_Mesh_ColorPointer(NULL);
2953                 R_Mesh_ResetTextureState();
2954         }
2955         RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
2956         RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
2957 }
2958
2959 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, msurface_t **texturesurfacelist)
2960 {
2961         // transparent sky would be ridiculous
2962         if ((rsurface_texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT))
2963                 return;
2964         if (rsurface_mode != RSURFMODE_SKY)
2965         {
2966                 if (rsurface_mode == RSURFMODE_GLSL)
2967                 {
2968                         qglUseProgramObjectARB(0);CHECKGLERROR
2969                 }
2970                 rsurface_mode = RSURFMODE_SKY;
2971         }
2972         if (skyrendernow)
2973         {
2974                 skyrendernow = false;
2975                 R_Sky();
2976                 // restore entity matrix
2977                 R_Mesh_Matrix(&rsurface_entity->matrix);
2978         }
2979         GL_DepthMask(true);
2980         // LordHavoc: HalfLife maps have freaky skypolys so don't use
2981         // skymasking on them, and Quake3 never did sky masking (unlike
2982         // software Quake and software Quake2), so disable the sky masking
2983         // in Quake3 maps as it causes problems with q3map2 sky tricks,
2984         // and skymasking also looks very bad when noclipping outside the
2985         // level, so don't use it then either.
2986         if (rsurface_model->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_viewcache.world_novis)
2987         {
2988                 GL_Color(r_refdef.fogcolor[0] * r_view.colorscale, r_refdef.fogcolor[1] * r_view.colorscale, r_refdef.fogcolor[2] * r_view.colorscale, 1);
2989                 R_Mesh_ColorPointer(NULL);
2990                 R_Mesh_ResetTextureState();
2991                 if (skyrendermasked)
2992                 {
2993                         // depth-only (masking)
2994                         GL_ColorMask(0,0,0,0);
2995                         // just to make sure that braindead drivers don't draw
2996                         // anything despite that colormask...
2997                         GL_BlendFunc(GL_ZERO, GL_ONE);
2998                 }
2999                 else
3000                 {
3001                         // fog sky
3002                         GL_BlendFunc(GL_ONE, GL_ZERO);
3003                 }
3004                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
3005                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
3006                 if (skyrendermasked)
3007                         GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
3008         }
3009 }
3010
3011 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, msurface_t **texturesurfacelist)
3012 {
3013         int lightmode;
3014         // FIXME: identify models using a better check than rsurface_model->brush.shadowmesh
3015         lightmode = ((rsurface_entity->effects & EF_FULLBRIGHT) || rsurface_model->brush.shadowmesh) ? 0 : 2;
3016         if (rsurface_mode != RSURFMODE_GLSL)
3017         {
3018                 rsurface_mode = RSURFMODE_GLSL;
3019                 rsurface_glsl_texture = NULL;
3020                 rsurface_glsl_uselightmap = false;
3021                 R_Mesh_ResetTextureState();
3022         }
3023         if (rsurface_glsl_texture != rsurface_texture || rsurface_glsl_uselightmap != (rsurface_lightmaptexture != NULL))
3024         {
3025                 rsurface_glsl_texture = rsurface_texture;
3026                 rsurface_glsl_uselightmap = rsurface_lightmaptexture != NULL;
3027                 GL_BlendFunc(rsurface_texture->currentlayers[0].blendfunc1, rsurface_texture->currentlayers[0].blendfunc2);
3028                 GL_DepthMask(!(rsurface_texture->currentmaterialflags & MATERIALFLAG_BLENDED));
3029                 GL_Color(rsurface_entity->colormod[0], rsurface_entity->colormod[1], rsurface_entity->colormod[2], rsurface_texture->currentalpha);
3030                 R_SetupSurfaceShader(vec3_origin, lightmode == 2);
3031                 //permutation_deluxemapping = permutation_lightmapping = R_SetupSurfaceShader(vec3_origin, lightmode == 2, false);
3032                 //if (r_glsl_deluxemapping.integer)
3033                 //      permutation_deluxemapping = R_SetupSurfaceShader(vec3_origin, lightmode == 2, true);
3034                 R_Mesh_TexCoordPointer(0, 2, rsurface_model->surfmesh.data_texcoordtexture2f);
3035                 R_Mesh_TexCoordPointer(4, 2, rsurface_model->surfmesh.data_texcoordlightmap2f);
3036                 GL_AlphaTest((rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
3037         }
3038         if (!r_glsl_permutation)
3039                 return;
3040         RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
3041         R_Mesh_TexCoordPointer(1, 3, rsurface_svector3f);
3042         R_Mesh_TexCoordPointer(2, 3, rsurface_tvector3f);
3043         R_Mesh_TexCoordPointer(3, 3, rsurface_normal3f);
3044         if (rsurface_texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
3045         {
3046                 R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
3047                 if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
3048                         R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
3049                 R_Mesh_ColorPointer(NULL);
3050         }
3051         else if (rsurface_lightmaptexture)
3052         {
3053                 R_Mesh_TexBind(7, R_GetTexture(rsurface_lightmaptexture));
3054                 if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
3055                         R_Mesh_TexBind(8, R_GetTexture(texturesurfacelist[0]->deluxemaptexture));
3056                 R_Mesh_ColorPointer(NULL);
3057         }
3058         else
3059         {
3060                 R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
3061                 if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
3062                         R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
3063                 R_Mesh_ColorPointer(rsurface_model->surfmesh.data_lightmapcolor4f);
3064         }
3065         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
3066 }
3067
3068 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **texturesurfacelist)
3069 {
3070         // OpenGL 1.3 path - anything not completely ancient
3071         int texturesurfaceindex;
3072         int lightmode;
3073         qboolean applycolor;
3074         qboolean applyfog;
3075         rmeshstate_t m;
3076         int layerindex;
3077         const texturelayer_t *layer;
3078         CHECKGLERROR
3079         // FIXME: identify models using a better check than rsurface_model->brush.shadowmesh
3080         lightmode = ((rsurface_entity->effects & EF_FULLBRIGHT) || rsurface_model->brush.shadowmesh) ? 0 : 2;
3081         if (rsurface_mode != RSURFMODE_MULTIPASS)
3082                 rsurface_mode = RSURFMODE_MULTIPASS;
3083         RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
3084         for (layerindex = 0, layer = rsurface_texture->currentlayers;layerindex < rsurface_texture->currentnumlayers;layerindex++, layer++)
3085         {
3086                 vec4_t layercolor;
3087                 int layertexrgbscale;
3088                 if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
3089                 {
3090                         if (layerindex == 0)
3091                                 GL_AlphaTest(true);
3092                         else
3093                         {
3094                                 GL_AlphaTest(false);
3095                                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
3096                         }
3097                 }
3098                 GL_DepthMask(layer->depthmask);
3099                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
3100                 if ((layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2) && (gl_combine.integer || layer->depthmask))
3101                 {
3102                         layertexrgbscale = 4;
3103                         VectorScale(layer->color, 0.25f, layercolor);
3104                 }
3105                 else if ((layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1) && (gl_combine.integer || layer->depthmask))
3106                 {
3107                         layertexrgbscale = 2;
3108                         VectorScale(layer->color, 0.5f, layercolor);
3109                 }
3110                 else
3111                 {
3112                         layertexrgbscale = 1;
3113                         VectorScale(layer->color, 1.0f, layercolor);
3114                 }
3115                 layercolor[3] = layer->color[3];
3116                 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
3117                 R_Mesh_ColorPointer(NULL);