disable water rendering without r_glsl because the fallback path has
[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 #include "image.h"
26
27 mempool_t *r_main_mempool;
28 rtexturepool_t *r_main_texturepool;
29
30 //
31 // screen size info
32 //
33 r_refdef_t r_refdef;
34 r_view_t r_view;
35 r_viewcache_t r_viewcache;
36
37 cvar_t r_depthfirst = {CVAR_SAVE, "r_depthfirst", "1", "renders a depth-only version of the scene before normal rendering begins to eliminate overdraw, values: 0 = off, 1 = world depth, 2 = world and model depth"};
38 cvar_t r_nearclip = {0, "r_nearclip", "1", "distance from camera of nearclip plane" };
39 cvar_t r_showbboxes = {0, "r_showbboxes", "0", "shows bounding boxes of server entities, value controls opacity scaling (1 = 10%,  10 = 100%)"};
40 cvar_t r_showsurfaces = {0, "r_showsurfaces", "0", "1 shows surfaces as different colors, or a value of 2 shows triangle draw order (for analyzing whether meshes are optimized for vertex cache)"};
41 cvar_t r_showtris = {0, "r_showtris", "0", "shows triangle outlines, value controls brightness (can be above 1)"};
42 cvar_t r_shownormals = {0, "r_shownormals", "0", "shows per-vertex surface normals and tangent vectors for bumpmapped lighting"};
43 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"};
44 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"};
45 cvar_t r_showcollisionbrushes = {0, "r_showcollisionbrushes", "0", "draws collision brushes in quake3 maps (mode 1), mode 2 disables rendering of world (trippy!)"};
46 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"};
47 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"};
48 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"};
49 cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating polygons) in world interior in quake1 maps"};
50 cvar_t r_drawentities = {0, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"};
51 cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1", "draw your weapon model"};
52 cvar_t r_cullentities_trace = {0, "r_cullentities_trace", "1", "probabistically cull invisible entities"};
53 cvar_t r_cullentities_trace_samples = {0, "r_cullentities_trace_samples", "2", "number of samples to test for entity culling"};
54 cvar_t r_cullentities_trace_enlarge = {0, "r_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
55 cvar_t r_cullentities_trace_delay = {0, "r_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
56 cvar_t r_speeds = {0, "r_speeds","0", "displays rendering statistics and per-subsystem timings"};
57 cvar_t r_fullbright = {0, "r_fullbright","0", "makes map very bright and renders faster"};
58 cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1", "opacity of water polygons"};
59 cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1", "enables dynamic lights (rocket glow and such)"};
60 cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1", "enables glowing pixels in quake textures (changes need r_restart to take effect)"};
61 cvar_t r_shadows = {CVAR_SAVE, "r_shadows", "0", "casts fake stencil shadows from models onto the world (rtlights are unaffected by this)"};
62 cvar_t r_shadows_throwdistance = {CVAR_SAVE, "r_shadows_throwdistance", "500", "how far to cast shadows from models"};
63 cvar_t r_q1bsp_skymasking = {0, "r_q1bsp_skymasking", "1", "allows sky polygons in quake1 maps to obscure other geometry"};
64 cvar_t r_polygonoffset_submodel_factor = {0, "r_polygonoffset_submodel_factor", "0", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
65 cvar_t r_polygonoffset_submodel_offset = {0, "r_polygonoffset_submodel_offset", "2", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
66
67 cvar_t gl_fogenable = {0, "gl_fogenable", "0", "nehahra fog enable (for Nehahra compatibility only)"};
68 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25", "nehahra fog density (recommend values below 0.1) (for Nehahra compatibility only)"};
69 cvar_t gl_fogred = {0, "gl_fogred","0.3", "nehahra fog color red value (for Nehahra compatibility only)"};
70 cvar_t gl_foggreen = {0, "gl_foggreen","0.3", "nehahra fog color green value (for Nehahra compatibility only)"};
71 cvar_t gl_fogblue = {0, "gl_fogblue","0.3", "nehahra fog color blue value (for Nehahra compatibility only)"};
72 cvar_t gl_fogstart = {0, "gl_fogstart", "0", "nehahra fog start distance (for Nehahra compatibility only)"};
73 cvar_t gl_fogend = {0, "gl_fogend","0", "nehahra fog end distance (for Nehahra compatibility only)"};
74
75 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)"};
76
77 cvar_t r_glsl = {CVAR_SAVE, "r_glsl", "1", "enables use of OpenGL 2.0 pixel shaders for lighting"};
78 cvar_t r_glsl_offsetmapping = {CVAR_SAVE, "r_glsl_offsetmapping", "0", "offset mapping effect (also known as parallax mapping or virtual displacement mapping)"};
79 cvar_t r_glsl_offsetmapping_reliefmapping = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"};
80 cvar_t r_glsl_offsetmapping_scale = {CVAR_SAVE, "r_glsl_offsetmapping_scale", "0.04", "how deep the offset mapping effect is"};
81 cvar_t r_glsl_deluxemapping = {CVAR_SAVE, "r_glsl_deluxemapping", "1", "use per pixel lighting on deluxemap-compiled q3bsp maps (or a value of 2 forces deluxemap shading even without deluxemaps)"};
82 cvar_t r_glsl_contrastboost = {CVAR_SAVE, "r_glsl_contrastboost", "1", "by how much to multiply the contrast in dark areas (1 is no change)"};
83
84 cvar_t r_water = {CVAR_SAVE, "r_water", "0", "whether to use reflections and refraction on water surfaces (note: r_wateralpha must be set below 1)"};
85 cvar_t r_water_clippingplanebias = {CVAR_SAVE, "r_water_clippingplanebias", "1", "a rather technical setting which avoids black pixels around water edges"};
86 cvar_t r_water_resolutionmultiplier = {CVAR_SAVE, "r_water_resolutionmultiplier", "0.5", "multiplier for screen resolution when rendering refracted/reflected scenes, 1 is full quality, lower values are faster"};
87 cvar_t r_water_refractdistort = {CVAR_SAVE, "r_water_refractdistort", "0.01", "how much water refractions shimmer"};
88 cvar_t r_water_reflectdistort = {CVAR_SAVE, "r_water_reflectdistort", "0.01", "how much water reflections shimmer"};
89
90 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "1", "enables animation smoothing on sprites (requires r_lerpmodels 1)"};
91 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"};
92 cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1", "makes water scroll around, value controls how much"};
93
94 cvar_t r_bloom = {CVAR_SAVE, "r_bloom", "0", "enables bloom effect (makes bright pixels affect neighboring pixels)"};
95 cvar_t r_bloom_colorscale = {CVAR_SAVE, "r_bloom_colorscale", "1", "how bright the glow is"};
96 cvar_t r_bloom_brighten = {CVAR_SAVE, "r_bloom_brighten", "2", "how bright the glow is, after subtract/power"};
97 cvar_t r_bloom_blur = {CVAR_SAVE, "r_bloom_blur", "4", "how large the glow is"};
98 cvar_t r_bloom_resolution = {CVAR_SAVE, "r_bloom_resolution", "320", "what resolution to perform the bloom effect at (independent of screen resolution)"};
99 cvar_t r_bloom_colorexponent = {CVAR_SAVE, "r_bloom_colorexponent", "1", "how exagerated the glow is"};
100 cvar_t r_bloom_colorsubtract = {CVAR_SAVE, "r_bloom_colorsubtract", "0.125", "reduces bloom colors by a certain amount"};
101
102 cvar_t r_hdr = {CVAR_SAVE, "r_hdr", "0", "enables High Dynamic Range bloom effect (higher quality version of r_bloom)"};
103 cvar_t r_hdr_scenebrightness = {CVAR_SAVE, "r_hdr_scenebrightness", "1", "global rendering brightness"};
104 cvar_t r_hdr_glowintensity = {CVAR_SAVE, "r_hdr_glowintensity", "1", "how bright light emitting textures should appear"};
105 cvar_t r_hdr_range = {CVAR_SAVE, "r_hdr_range", "4", "how much dynamic range to render bloom with (equivilant to multiplying r_bloom_brighten by this value and dividing r_bloom_colorscale by this value)"};
106
107 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"};
108
109 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"};
110
111 cvar_t gl_lightmaps = {0, "gl_lightmaps", "0", "draws only lightmaps, no texture (for level designers)"};
112
113 cvar_t r_test = {0, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"};
114 cvar_t r_batchmode = {0, "r_batchmode", "1", "selects method of rendering multiple surfaces with one driver call (values are 0, 1, 2, etc...)"};
115
116 extern qboolean v_flipped_state;
117
118 typedef struct r_glsl_bloomshader_s
119 {
120         int program;
121         int loc_Texture_Bloom;
122 }
123 r_glsl_bloomshader_t;
124
125 static struct r_bloomstate_s
126 {
127         qboolean enabled;
128         qboolean hdr;
129
130         int bloomwidth, bloomheight;
131
132         int screentexturewidth, screentextureheight;
133         rtexture_t *texture_screen;
134
135         int bloomtexturewidth, bloomtextureheight;
136         rtexture_t *texture_bloom;
137
138         r_glsl_bloomshader_t *shader;
139
140         // arrays for rendering the screen passes
141         float screentexcoord2f[8];
142         float bloomtexcoord2f[8];
143         float offsettexcoord2f[8];
144 }
145 r_bloomstate;
146
147 typedef struct r_waterstate_waterplane_s
148 {
149         rtexture_t *texture_refraction;
150         rtexture_t *texture_reflection;
151         mplane_t plane;
152         int materialflags; // combined flags of all water surfaces on this plane
153         unsigned char pvsbits[(32768+7)>>3]; // FIXME: buffer overflow on huge maps
154         qboolean pvsvalid;
155 }
156 r_waterstate_waterplane_t;
157
158 #define MAX_WATERPLANES 16
159
160 static struct r_waterstate_s
161 {
162         qboolean enabled;
163
164         qboolean renderingscene; // true while rendering a refraction or reflection texture, disables water surfaces
165
166         int waterwidth, waterheight;
167         int texturewidth, textureheight;
168
169         int maxwaterplanes; // same as MAX_WATERPLANES
170         int numwaterplanes;
171         r_waterstate_waterplane_t waterplanes[MAX_WATERPLANES];
172
173         float screenscale[2];
174         float screencenter[2];
175 }
176 r_waterstate;
177
178 // shadow volume bsp struct with automatically growing nodes buffer
179 svbsp_t r_svbsp;
180
181 rtexture_t *r_texture_blanknormalmap;
182 rtexture_t *r_texture_white;
183 rtexture_t *r_texture_grey128;
184 rtexture_t *r_texture_black;
185 rtexture_t *r_texture_notexture;
186 rtexture_t *r_texture_whitecube;
187 rtexture_t *r_texture_normalizationcube;
188 rtexture_t *r_texture_fogattenuation;
189 //rtexture_t *r_texture_fogintensity;
190
191 char r_qwskincache[MAX_SCOREBOARD][MAX_QPATH];
192 skinframe_t *r_qwskincache_skinframe[MAX_SCOREBOARD];
193
194 // vertex coordinates for a quad that covers the screen exactly
195 const static float r_screenvertex3f[12] =
196 {
197         0, 0, 0,
198         1, 0, 0,
199         1, 1, 0,
200         0, 1, 0
201 };
202
203 extern void R_DrawModelShadows(void);
204
205 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
206 {
207         int i;
208         for (i = 0;i < verts;i++)
209         {
210                 out[0] = in[0] * r;
211                 out[1] = in[1] * g;
212                 out[2] = in[2] * b;
213                 out[3] = in[3];
214                 in += 4;
215                 out += 4;
216         }
217 }
218
219 void R_FillColors(float *out, int verts, float r, float g, float b, float a)
220 {
221         int i;
222         for (i = 0;i < verts;i++)
223         {
224                 out[0] = r;
225                 out[1] = g;
226                 out[2] = b;
227                 out[3] = a;
228                 out += 4;
229         }
230 }
231
232 // FIXME: move this to client?
233 void FOG_clear(void)
234 {
235         if (gamemode == GAME_NEHAHRA)
236         {
237                 Cvar_Set("gl_fogenable", "0");
238                 Cvar_Set("gl_fogdensity", "0.2");
239                 Cvar_Set("gl_fogred", "0.3");
240                 Cvar_Set("gl_foggreen", "0.3");
241                 Cvar_Set("gl_fogblue", "0.3");
242         }
243         r_refdef.fog_density = r_refdef.fog_red = r_refdef.fog_green = r_refdef.fog_blue = 0.0f;
244 }
245
246 float FogPoint_World(const vec3_t p)
247 {
248         int fogmasktableindex = (int)(VectorDistance((p), r_view.origin) * r_refdef.fogmasktabledistmultiplier);
249         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
250 }
251
252 float FogPoint_Model(const vec3_t p)
253 {
254         int fogmasktableindex = (int)(VectorDistance((p), rsurface.modelorg) * r_refdef.fogmasktabledistmultiplier);
255         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
256 }
257
258 static void R_BuildBlankTextures(void)
259 {
260         unsigned char data[4];
261         data[0] = 128; // normal X
262         data[1] = 128; // normal Y
263         data[2] = 255; // normal Z
264         data[3] = 128; // height
265         r_texture_blanknormalmap = R_LoadTexture2D(r_main_texturepool, "blankbump", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
266         data[0] = 255;
267         data[1] = 255;
268         data[2] = 255;
269         data[3] = 255;
270         r_texture_white = R_LoadTexture2D(r_main_texturepool, "blankwhite", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
271         data[0] = 128;
272         data[1] = 128;
273         data[2] = 128;
274         data[3] = 255;
275         r_texture_grey128 = R_LoadTexture2D(r_main_texturepool, "blankgrey128", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
276         data[0] = 0;
277         data[1] = 0;
278         data[2] = 0;
279         data[3] = 255;
280         r_texture_black = R_LoadTexture2D(r_main_texturepool, "blankblack", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
281 }
282
283 static void R_BuildNoTexture(void)
284 {
285         int x, y;
286         unsigned char pix[16][16][4];
287         // this makes a light grey/dark grey checkerboard texture
288         for (y = 0;y < 16;y++)
289         {
290                 for (x = 0;x < 16;x++)
291                 {
292                         if ((y < 8) ^ (x < 8))
293                         {
294                                 pix[y][x][0] = 128;
295                                 pix[y][x][1] = 128;
296                                 pix[y][x][2] = 128;
297                                 pix[y][x][3] = 255;
298                         }
299                         else
300                         {
301                                 pix[y][x][0] = 64;
302                                 pix[y][x][1] = 64;
303                                 pix[y][x][2] = 64;
304                                 pix[y][x][3] = 255;
305                         }
306                 }
307         }
308         r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_RGBA, TEXF_MIPMAP, NULL);
309 }
310
311 static void R_BuildWhiteCube(void)
312 {
313         unsigned char data[6*1*1*4];
314         data[ 0] = 255;data[ 1] = 255;data[ 2] = 255;data[ 3] = 255;
315         data[ 4] = 255;data[ 5] = 255;data[ 6] = 255;data[ 7] = 255;
316         data[ 8] = 255;data[ 9] = 255;data[10] = 255;data[11] = 255;
317         data[12] = 255;data[13] = 255;data[14] = 255;data[15] = 255;
318         data[16] = 255;data[17] = 255;data[18] = 255;data[19] = 255;
319         data[20] = 255;data[21] = 255;data[22] = 255;data[23] = 255;
320         r_texture_whitecube = R_LoadTextureCubeMap(r_main_texturepool, "whitecube", 1, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL);
321 }
322
323 static void R_BuildNormalizationCube(void)
324 {
325         int x, y, side;
326         vec3_t v;
327         vec_t s, t, intensity;
328 #define NORMSIZE 64
329         unsigned char data[6][NORMSIZE][NORMSIZE][4];
330         for (side = 0;side < 6;side++)
331         {
332                 for (y = 0;y < NORMSIZE;y++)
333                 {
334                         for (x = 0;x < NORMSIZE;x++)
335                         {
336                                 s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
337                                 t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
338                                 switch(side)
339                                 {
340                                 default:
341                                 case 0:
342                                         v[0] = 1;
343                                         v[1] = -t;
344                                         v[2] = -s;
345                                         break;
346                                 case 1:
347                                         v[0] = -1;
348                                         v[1] = -t;
349                                         v[2] = s;
350                                         break;
351                                 case 2:
352                                         v[0] = s;
353                                         v[1] = 1;
354                                         v[2] = t;
355                                         break;
356                                 case 3:
357                                         v[0] = s;
358                                         v[1] = -1;
359                                         v[2] = -t;
360                                         break;
361                                 case 4:
362                                         v[0] = s;
363                                         v[1] = -t;
364                                         v[2] = 1;
365                                         break;
366                                 case 5:
367                                         v[0] = -s;
368                                         v[1] = -t;
369                                         v[2] = -1;
370                                         break;
371                                 }
372                                 intensity = 127.0f / sqrt(DotProduct(v, v));
373                                 data[side][y][x][0] = (unsigned char)(128.0f + intensity * v[0]);
374                                 data[side][y][x][1] = (unsigned char)(128.0f + intensity * v[1]);
375                                 data[side][y][x][2] = (unsigned char)(128.0f + intensity * v[2]);
376                                 data[side][y][x][3] = 255;
377                         }
378                 }
379         }
380         r_texture_normalizationcube = R_LoadTextureCubeMap(r_main_texturepool, "normalcube", NORMSIZE, &data[0][0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL);
381 }
382
383 static void R_BuildFogTexture(void)
384 {
385         int x, b;
386 #define FOGWIDTH 64
387         unsigned char data1[FOGWIDTH][4];
388         //unsigned char data2[FOGWIDTH][4];
389         for (x = 0;x < FOGWIDTH;x++)
390         {
391                 b = (int)(r_refdef.fogmasktable[x * (FOGMASKTABLEWIDTH - 1) / (FOGWIDTH - 1)] * 255);
392                 data1[x][0] = b;
393                 data1[x][1] = b;
394                 data1[x][2] = b;
395                 data1[x][3] = 255;
396                 //data2[x][0] = 255 - b;
397                 //data2[x][1] = 255 - b;
398                 //data2[x][2] = 255 - b;
399                 //data2[x][3] = 255;
400         }
401         r_texture_fogattenuation = R_LoadTexture2D(r_main_texturepool, "fogattenuation", FOGWIDTH, 1, &data1[0][0], TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_FORCELINEAR | TEXF_CLAMP, NULL);
402         //r_texture_fogintensity = R_LoadTexture2D(r_main_texturepool, "fogintensity", FOGWIDTH, 1, &data2[0][0], TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_FORCELINEAR | TEXF_CLAMP, NULL);
403 }
404
405 static const char *builtinshaderstring =
406 "// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
407 "// written by Forest 'LordHavoc' Hale\n"
408 "\n"
409 "// common definitions between vertex shader and fragment shader:\n"
410 "\n"
411 "#ifdef __GLSL_CG_DATA_TYPES\n"
412 "# define myhalf half\n"
413 "# define myhvec2 hvec2\n"
414 "# define myhvec3 hvec3\n"
415 "# define myhvec4 hvec4\n"
416 "#else\n"
417 "# define myhalf float\n"
418 "# define myhvec2 vec2\n"
419 "# define myhvec3 vec3\n"
420 "# define myhvec4 vec4\n"
421 "#endif\n"
422 "\n"
423 "varying vec2 TexCoord;\n"
424 "varying vec2 TexCoordLightmap;\n"
425 "\n"
426 "//#ifdef MODE_LIGHTSOURCE\n"
427 "varying vec3 CubeVector;\n"
428 "//#endif\n"
429 "\n"
430 "//#ifdef MODE_LIGHTSOURCE\n"
431 "varying vec3 LightVector;\n"
432 "//#else\n"
433 "//# ifdef MODE_LIGHTDIRECTION\n"
434 "//varying vec3 LightVector;\n"
435 "//# endif\n"
436 "//#endif\n"
437 "\n"
438 "varying vec3 EyeVector;\n"
439 "//#ifdef USEFOG\n"
440 "varying vec3 EyeVectorModelSpace;\n"
441 "//#endif\n"
442 "\n"
443 "varying vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n"
444 "varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
445 "varying vec3 VectorR; // direction of R texcoord (surface normal)\n"
446 "\n"
447 "//#ifdef MODE_WATER\n"
448 "varying vec4 ModelViewProjectionPosition;\n"
449 "//#else\n"
450 "//# ifdef MODE_REFRACTION\n"
451 "//varying vec4 ModelViewProjectionPosition;\n"
452 "//# else\n"
453 "//#  ifdef USEREFLECTION\n"
454 "//varying vec4 ModelViewProjectionPosition;\n"
455 "//#  endif\n"
456 "//# endif\n"
457 "//#endif\n"
458 "\n"
459 "\n"
460 "\n"
461 "\n"
462 "\n"
463 "// vertex shader specific:\n"
464 "#ifdef VERTEX_SHADER\n"
465 "\n"
466 "uniform vec3 LightPosition;\n"
467 "uniform vec3 EyePosition;\n"
468 "uniform vec3 LightDir;\n"
469 "\n"
470 "// TODO: get rid of tangentt (texcoord2) and use a crossproduct to regenerate it from tangents (texcoord1) and normal (texcoord3)\n"
471 "\n"
472 "void main(void)\n"
473 "{\n"
474 "       gl_FrontColor = gl_Color;\n"
475 "       // copy the surface texcoord\n"
476 "       TexCoord = vec2(gl_TextureMatrix[0] * gl_MultiTexCoord0);\n"
477 "#ifndef MODE_LIGHTSOURCE\n"
478 "# ifndef MODE_LIGHTDIRECTION\n"
479 "       TexCoordLightmap = vec2(gl_MultiTexCoord4);\n"
480 "# endif\n"
481 "#endif\n"
482 "\n"
483 "#ifdef MODE_LIGHTSOURCE\n"
484 "       // transform vertex position into light attenuation/cubemap space\n"
485 "       // (-1 to +1 across the light box)\n"
486 "       CubeVector = vec3(gl_TextureMatrix[3] * gl_Vertex);\n"
487 "\n"
488 "       // transform unnormalized light direction into tangent space\n"
489 "       // (we use unnormalized to ensure that it interpolates correctly and then\n"
490 "       //  normalize it per pixel)\n"
491 "       vec3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
492 "       LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
493 "       LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
494 "       LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
495 "#endif\n"
496 "\n"
497 "#ifdef MODE_LIGHTDIRECTION\n"
498 "       LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);\n"
499 "       LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);\n"
500 "       LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);\n"
501 "#endif\n"
502 "\n"
503 "       // transform unnormalized eye direction into tangent space\n"
504 "#ifndef USEFOG\n"
505 "       vec3 EyeVectorModelSpace;\n"
506 "#endif\n"
507 "       EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
508 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
509 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
510 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
511 "\n"
512 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
513 "       VectorS = gl_MultiTexCoord1.xyz;\n"
514 "       VectorT = gl_MultiTexCoord2.xyz;\n"
515 "       VectorR = gl_MultiTexCoord3.xyz;\n"
516 "#endif\n"
517 "\n"
518 "//#if defined(MODE_WATER) || defined(MODE_REFRACTION) || defined(USEREFLECTION)\n"
519 "//     ModelViewProjectionPosition = gl_Vertex * gl_ModelViewProjectionMatrix;\n"
520 "//     //ModelViewProjectionPosition_svector = (gl_Vertex + vec4(gl_MultiTexCoord1.xyz, 0)) * gl_ModelViewProjectionMatrix - ModelViewProjectionPosition;\n"
521 "//     //ModelViewProjectionPosition_tvector = (gl_Vertex + vec4(gl_MultiTexCoord2.xyz, 0)) * gl_ModelViewProjectionMatrix - ModelViewProjectionPosition;\n"
522 "//#endif\n"
523 "\n"
524 "// transform vertex to camera space, using ftransform to match non-VS\n"
525 "       // rendering\n"
526 "       gl_Position = ftransform();\n"
527 "\n"
528 "#ifdef MODE_WATER\n"
529 "       ModelViewProjectionPosition = gl_Position;\n"
530 "#endif\n"
531 "#ifdef MODE_REFRACTION\n"
532 "       ModelViewProjectionPosition = gl_Position;\n"
533 "#endif\n"
534 "#ifdef USEREFLECTION\n"
535 "       ModelViewProjectionPosition = gl_Position;\n"
536 "#endif\n"
537 "}\n"
538 "\n"
539 "#endif // VERTEX_SHADER\n"
540 "\n"
541 "\n"
542 "\n"
543 "\n"
544 "// fragment shader specific:\n"
545 "#ifdef FRAGMENT_SHADER\n"
546 "\n"
547 "// 13 textures, we can only use up to 16 on DX9-class hardware\n"
548 "uniform sampler2D Texture_Normal;\n"
549 "uniform sampler2D Texture_Color;\n"
550 "uniform sampler2D Texture_Gloss;\n"
551 "uniform samplerCube Texture_Cube;\n"
552 "uniform sampler2D Texture_Attenuation;\n"
553 "uniform sampler2D Texture_FogMask;\n"
554 "uniform sampler2D Texture_Pants;\n"
555 "uniform sampler2D Texture_Shirt;\n"
556 "uniform sampler2D Texture_Lightmap;\n"
557 "uniform sampler2D Texture_Deluxemap;\n"
558 "uniform sampler2D Texture_Glow;\n"
559 "uniform sampler2D Texture_Reflection;\n"
560 "uniform sampler2D Texture_Refraction;\n"
561 "\n"
562 "uniform myhvec3 LightColor;\n"
563 "uniform myhvec3 AmbientColor;\n"
564 "uniform myhvec3 DiffuseColor;\n"
565 "uniform myhvec3 SpecularColor;\n"
566 "uniform myhvec3 Color_Pants;\n"
567 "uniform myhvec3 Color_Shirt;\n"
568 "uniform myhvec3 FogColor;\n"
569 "\n"
570 "//#ifdef MODE_WATER\n"
571 "uniform vec4 DistortScaleRefractReflect;\n"
572 "uniform vec4 ScreenScaleRefractReflect;\n"
573 "uniform vec4 ScreenCenterRefractReflect;\n"
574 "uniform myhvec4 RefractColor;\n"
575 "uniform myhvec4 ReflectColor;\n"
576 "uniform myhalf ReflectFactor;\n"
577 "uniform myhalf ReflectOffset;\n"
578 "//#else\n"
579 "//# ifdef MODE_REFRACTION\n"
580 "//uniform vec4 DistortScaleRefractReflect;\n"
581 "//uniform vec4 ScreenScaleRefractReflect;\n"
582 "//uniform vec4 ScreenCenterRefractReflect;\n"
583 "//uniform myhvec4 RefractColor;\n"
584 "//#  ifdef USEREFLECTION\n"
585 "//uniform myhvec4 ReflectColor;\n"
586 "//#  endif\n"
587 "//# else\n"
588 "//#  ifdef USEREFLECTION\n"
589 "//uniform vec4 DistortScaleRefractReflect;\n"
590 "//uniform vec4 ScreenScaleRefractReflect;\n"
591 "//uniform vec4 ScreenCenterRefractReflect;\n"
592 "//uniform myhvec4 ReflectColor;\n"
593 "//#  endif\n"
594 "//# endif\n"
595 "//#endif\n"
596 "\n"
597 "uniform myhalf GlowScale;\n"
598 "uniform myhalf SceneBrightness;\n"
599 "#ifdef USECONTRASTBOOST\n"
600 "uniform myhalf ContrastBoostCoeff;\n"
601 "#endif\n"
602 "\n"
603 "uniform float OffsetMapping_Scale;\n"
604 "uniform float OffsetMapping_Bias;\n"
605 "uniform float FogRangeRecip;\n"
606 "\n"
607 "uniform myhalf AmbientScale;\n"
608 "uniform myhalf DiffuseScale;\n"
609 "uniform myhalf SpecularScale;\n"
610 "uniform myhalf SpecularPower;\n"
611 "\n"
612 "#ifdef USEOFFSETMAPPING\n"
613 "vec2 OffsetMapping(vec2 TexCoord)\n"
614 "{\n"
615 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
616 "       // 14 sample relief mapping: linear search and then binary search\n"
617 "       // this basically steps forward a small amount repeatedly until it finds\n"
618 "       // itself inside solid, then jitters forward and back using decreasing\n"
619 "       // amounts to find the impact\n"
620 "       //vec3 OffsetVector = vec3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1), -1);\n"
621 "       //vec3 OffsetVector = vec3(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
622 "       vec3 OffsetVector = vec3(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
623 "       vec3 RT = vec3(TexCoord, 1);\n"
624 "       OffsetVector *= 0.1;\n"
625 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
626 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
627 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
628 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
629 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
630 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
631 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
632 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
633 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
634 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z)          - 0.5);\n"
635 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.5    - 0.25);\n"
636 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.25   - 0.125);\n"
637 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.125  - 0.0625);\n"
638 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
639 "       return RT.xy;\n"
640 "#else\n"
641 "       // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
642 "       // this basically moves forward the full distance, and then backs up based\n"
643 "       // on height of samples\n"
644 "       //vec2 OffsetVector = vec2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1));\n"
645 "       //vec2 OffsetVector = vec2(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1));\n"
646 "       vec2 OffsetVector = vec2(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1));\n"
647 "       TexCoord += OffsetVector;\n"
648 "       OffsetVector *= 0.333;\n"
649 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
650 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
651 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
652 "       return TexCoord;\n"
653 "#endif\n"
654 "}\n"
655 "#endif // USEOFFSETMAPPING\n"
656 "\n"
657 "#ifdef MODE_WATER\n"
658 "\n"
659 "// water pass\n"
660 "void main(void)\n"
661 "{\n"
662 "#ifdef USEOFFSETMAPPING\n"
663 "       // apply offsetmapping\n"
664 "       vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
665 "#define TexCoord TexCoordOffset\n"
666 "#endif\n"
667 "\n"
668 "       vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
669 "       //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
670 "       vec4 ScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect + vec2(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
671 "       float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 5.0) * ReflectFactor + ReflectOffset;\n"
672 "       gl_FragColor = mix(texture2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, texture2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n"
673 "}\n"
674 "\n"
675 "#else // MODE_WATER\n"
676 "#ifdef MODE_REFRACTION\n"
677 "\n"
678 "// refraction pass\n"
679 "void main(void)\n"
680 "{\n"
681 "#ifdef USEOFFSETMAPPING\n"
682 "       // apply offsetmapping\n"
683 "       vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
684 "#define TexCoord TexCoordOffset\n"
685 "#endif\n"
686 "\n"
687 "       vec2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
688 "       //vec2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
689 "       vec2 ScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy + vec2(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xy * DistortScaleRefractReflect.xy;\n"
690 "       gl_FragColor = texture2D(Texture_Refraction, ScreenTexCoord) * RefractColor;\n"
691 "}\n"
692 "\n"
693 "#else // MODE_REFRACTION\n"
694 "void main(void)\n"
695 "{\n"
696 "#ifdef USEOFFSETMAPPING\n"
697 "       // apply offsetmapping\n"
698 "       vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
699 "#define TexCoord TexCoordOffset\n"
700 "#endif\n"
701 "\n"
702 "       // combine the diffuse textures (base, pants, shirt)\n"
703 "       myhvec4 color = myhvec4(texture2D(Texture_Color, TexCoord));\n"
704 "#ifdef USECOLORMAPPING\n"
705 "       color.rgb += myhvec3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + myhvec3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
706 "#endif\n"
707 "\n"
708 "\n"
709 "\n"
710 "\n"
711 "#ifdef MODE_LIGHTSOURCE\n"
712 "       // light source\n"
713 "\n"
714 "       // calculate surface normal, light normal, and specular normal\n"
715 "       // compute color intensity for the two textures (colormap and glossmap)\n"
716 "       // scale by light color and attenuation as efficiently as possible\n"
717 "       // (do as much scalar math as possible rather than vector math)\n"
718 "# ifdef USESPECULAR\n"
719 "       myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
720 "       myhvec3 diffusenormal = myhvec3(normalize(LightVector));\n"
721 "       myhvec3 specularnormal = normalize(diffusenormal + myhvec3(normalize(EyeVector)));\n"
722 "\n"
723 "       // calculate directional shading\n"
724 "       color.rgb = LightColor * myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0))) * (color.rgb * (AmbientScale + DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0))) + (SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower)) * myhvec3(texture2D(Texture_Gloss, TexCoord)));\n"
725 "# else\n"
726 "#  ifdef USEDIFFUSE\n"
727 "       myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
728 "       myhvec3 diffusenormal = myhvec3(normalize(LightVector));\n"
729 "\n"
730 "       // calculate directional shading\n"
731 "       color.rgb = color.rgb * LightColor * (myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0))) * (AmbientScale + DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0))));\n"
732 "#  else\n"
733 "       // calculate directionless shading\n"
734 "       color.rgb = color.rgb * LightColor * myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
735 "#  endif\n"
736 "# endif\n"
737 "\n"
738 "# ifdef USECUBEFILTER\n"
739 "       // apply light cubemap filter\n"
740 "       //color.rgb *= normalize(CubeVector) * 0.5 + 0.5;//vec3(textureCube(Texture_Cube, CubeVector));\n"
741 "       color.rgb *= myhvec3(textureCube(Texture_Cube, CubeVector));\n"
742 "# endif\n"
743 "       color *= myhvec4(gl_Color);\n"
744 "#endif // MODE_LIGHTSOURCE\n"
745 "\n"
746 "\n"
747 "\n"
748 "\n"
749 "#ifdef MODE_LIGHTDIRECTION\n"
750 "       // directional model lighting\n"
751 "\n"
752 "       // get the surface normal and light normal\n"
753 "       myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
754 "       myhvec3 diffusenormal = myhvec3(LightVector);\n"
755 "\n"
756 "       // calculate directional shading\n"
757 "       color.rgb *= AmbientColor + DiffuseColor * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
758 "# ifdef USESPECULAR\n"
759 "       myhvec3 specularnormal = normalize(diffusenormal + myhvec3(normalize(EyeVector)));\n"
760 "       color.rgb += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularColor * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
761 "# endif\n"
762 "       color *= myhvec4(gl_Color);\n"
763 "#endif // MODE_LIGHTDIRECTION\n"
764 "\n"
765 "\n"
766 "\n"
767 "\n"
768 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
769 "       // deluxemap lightmapping using light vectors in modelspace (evil q3map2)\n"
770 "\n"
771 "       // get the surface normal and light normal\n"
772 "       myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
773 "\n"
774 "       myhvec3 diffusenormal_modelspace = myhvec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - myhvec3(0.5);\n"
775 "       myhvec3 diffusenormal = normalize(myhvec3(dot(diffusenormal_modelspace, myhvec3(VectorS)), dot(diffusenormal_modelspace, myhvec3(VectorT)), dot(diffusenormal_modelspace, myhvec3(VectorR))));\n"
776 "       // calculate directional shading\n"
777 "       myhvec3 tempcolor = color.rgb * (DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0)));\n"
778 "# ifdef USESPECULAR\n"
779 "       myhvec3 specularnormal = myhvec3(normalize(diffusenormal + myhvec3(normalize(EyeVector))));\n"
780 "       tempcolor += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
781 "# endif\n"
782 "\n"
783 "       // apply lightmap color\n"
784 "       color.rgb = myhvec4(tempcolor,1) * myhvec4(texture2D(Texture_Lightmap, TexCoordLightmap)) * myhvec4(gl_Color) + myhvec4(color.rgb * AmbientScale, 0);\n"
785 "#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
786 "\n"
787 "\n"
788 "\n"
789 "\n"
790 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
791 "       // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
792 "\n"
793 "       // get the surface normal and light normal\n"
794 "       myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
795 "\n"
796 "       myhvec3 diffusenormal = normalize(myhvec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - myhvec3(0.5));\n"
797 "       // calculate directional shading\n"
798 "       myhvec3 tempcolor = color.rgb * (DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0)));\n"
799 "# ifdef USESPECULAR\n"
800 "       myhvec3 specularnormal = myhvec3(normalize(diffusenormal + myhvec3(normalize(EyeVector))));\n"
801 "       tempcolor += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
802 "# endif\n"
803 "\n"
804 "       // apply lightmap color\n"
805 "       color = myhvec4(tempcolor, 1) * myhvec4(texture2D(Texture_Lightmap, TexCoordLightmap)) * myhvec4(gl_Color) + myhvec4(color.rgb * AmbientScale, 0);\n"
806 "#endif // MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
807 "\n"
808 "\n"
809 "\n"
810 "\n"
811 "#ifdef MODE_LIGHTMAP\n"
812 "       // apply lightmap color\n"
813 "       color *= myhvec4(texture2D(Texture_Lightmap, TexCoordLightmap)) * myhvec4(gl_Color) * myhvec4(myhvec3(DiffuseScale), 1) + myhvec4(myhvec3(AmbientScale), 0);\n"
814 "#endif // MODE_LIGHTMAP\n"
815 "\n"
816 "\n"
817 "\n"
818 "\n"
819 "\n"
820 "\n"
821 "\n"
822 "\n"
823 "#ifdef USEGLOW\n"
824 "       color.rgb += myhvec3(texture2D(Texture_Glow, TexCoord)) * GlowScale;\n"
825 "#endif\n"
826 "\n"
827 "#ifndef MODE_LIGHTSOURCE\n"
828 "# ifdef USEREFLECTION\n"
829 "       vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
830 "       //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
831 "       vec4 ScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect + vec3(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
832 "       color.rgb = mix(color.rgb, myhvec3(texture2D(Texture_Reflection, ScreenTexCoord.zw)) * ReflectColor.rgb, ReflectColor.a);\n"
833 "# endif\n"
834 "#endif\n"
835 "\n"
836 "#ifdef USEFOG\n"
837 "       // apply fog\n"
838 "       color.rgb = mix(FogColor, color.rgb, myhalf(texture2D(Texture_FogMask, myhvec2(length(EyeVectorModelSpace)*FogRangeRecip, 0.0))));\n"
839 "#endif\n"
840 "\n"
841 "#ifdef USECONTRASTBOOST\n"
842 "       color.rgb = color.rgb / (ContrastBoostCoeff * color.rgb + myhvec3(1, 1, 1));\n"
843 "#endif\n"
844 "\n"
845 "       color.rgb *= SceneBrightness;\n"
846 "\n"
847 "       gl_FragColor = vec4(color);\n"
848 "}\n"
849 "#endif // MODE_REFRACTION\n"
850 "#endif // MODE_WATER\n"
851 "\n"
852 "#endif // FRAGMENT_SHADER\n"
853 ;
854
855 #define SHADERPERMUTATION_COLORMAPPING (1<<0) // indicates this is a colormapped skin
856 #define SHADERPERMUTATION_CONTRASTBOOST (1<<1) // r_glsl_contrastboost boosts the contrast at low color levels (similar to gamma)
857 #define SHADERPERMUTATION_FOG (1<<2) // tint the color by fog color or black if using additive blend mode
858 #define SHADERPERMUTATION_CUBEFILTER (1<<3) // (lightsource) use cubemap light filter
859 #define SHADERPERMUTATION_GLOW (1<<4) // (lightmap) blend in an additive glow texture
860 #define SHADERPERMUTATION_DIFFUSE (1<<5) // (lightsource) whether to use directional shading
861 #define SHADERPERMUTATION_SPECULAR (1<<6) // (lightsource or deluxemapping) render specular effects
862 #define SHADERPERMUTATION_REFLECTION (1<<7) // normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface
863 #define SHADERPERMUTATION_OFFSETMAPPING (1<<8) // adjust texcoords to roughly simulate a displacement mapped surface
864 #define SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING (1<<9) // adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!)
865 #define SHADERPERMUTATION_MODEBASE (1<<10) // multiplier for the SHADERMODE_ values to get a valid index
866
867 // NOTE: MUST MATCH ORDER OF SHADERPERMUTATION_* DEFINES!
868 const char *shaderpermutationinfo[][2] =
869 {
870         {"#define USECOLORMAPPING\n", " colormapping"},
871         {"#define USECONTRASTBOOST\n", " contrastboost"},
872         {"#define USEFOG\n", " fog"},
873         {"#define USECUBEFILTER\n", " cubefilter"},
874         {"#define USEGLOW\n", " glow"},
875         {"#define USEDIFFUSE\n", " diffuse"},
876         {"#define USESPECULAR\n", " specular"},
877         {"#define USEREFLECTION\n", " reflection"},
878         {"#define USEOFFSETMAPPING\n", " offsetmapping"},
879         {"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"},
880         {NULL, NULL}
881 };
882
883 // this enum is multiplied by SHADERPERMUTATION_MODEBASE
884 typedef enum shadermode_e
885 {
886         SHADERMODE_LIGHTMAP, // (lightmap) use directional pixel shading from fixed light direction (q3bsp)
887         SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE, // (lightmap) use directional pixel shading from texture containing modelspace light directions (deluxemap)
888         SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE, // (lightmap) use directional pixel shading from texture containing tangentspace light directions (deluxemap)
889         SHADERMODE_LIGHTDIRECTION, // (lightmap) use directional pixel shading from fixed light direction (q3bsp)
890         SHADERMODE_LIGHTSOURCE, // (lightsource) use directional pixel shading from light source (rtlight)
891         SHADERMODE_REFRACTION, // refract background (the material is rendered normally after this pass)
892         SHADERMODE_WATER, // refract background and reflection (the material is rendered normally after this pass)
893         SHADERMODE_COUNT
894 }
895 shadermode_t;
896
897 // NOTE: MUST MATCH ORDER OF SHADERMODE_* ENUMS!
898 const char *shadermodeinfo[][2] =
899 {
900         {"#define MODE_LIGHTMAP\n", " lightmap"},
901         {"#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
902         {"#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
903         {"#define MODE_LIGHTDIRECTION\n", " lightdirection"},
904         {"#define MODE_LIGHTSOURCE\n", " lightsource"},
905         {"#define MODE_REFRACTION\n", " refraction"},
906         {"#define MODE_WATER\n", " water"},
907         {NULL, NULL}
908 };
909
910 #define SHADERPERMUTATION_INDICES (SHADERPERMUTATION_MODEBASE * SHADERMODE_COUNT)
911
912 typedef struct r_glsl_permutation_s
913 {
914         // indicates if we have tried compiling this permutation already
915         qboolean compiled;
916         // 0 if compilation failed
917         int program;
918         // locations of detected uniforms in program object, or -1 if not found
919         int loc_Texture_Normal;
920         int loc_Texture_Color;
921         int loc_Texture_Gloss;
922         int loc_Texture_Cube;
923         int loc_Texture_Attenuation;
924         int loc_Texture_FogMask;
925         int loc_Texture_Pants;
926         int loc_Texture_Shirt;
927         int loc_Texture_Lightmap;
928         int loc_Texture_Deluxemap;
929         int loc_Texture_Glow;
930         int loc_Texture_Refraction;
931         int loc_Texture_Reflection;
932         int loc_FogColor;
933         int loc_LightPosition;
934         int loc_EyePosition;
935         int loc_LightColor;
936         int loc_Color_Pants;
937         int loc_Color_Shirt;
938         int loc_FogRangeRecip;
939         int loc_AmbientScale;
940         int loc_DiffuseScale;
941         int loc_SpecularScale;
942         int loc_SpecularPower;
943         int loc_GlowScale;
944         int loc_SceneBrightness; // or: Scenebrightness * ContrastBoost
945         int loc_OffsetMapping_Scale;
946         int loc_AmbientColor;
947         int loc_DiffuseColor;
948         int loc_SpecularColor;
949         int loc_LightDir;
950         int loc_ContrastBoostCoeff; // 1 - 1/ContrastBoost
951         int loc_DistortScaleRefractReflect;
952         int loc_ScreenScaleRefractReflect;
953         int loc_ScreenCenterRefractReflect;
954         int loc_RefractColor;
955         int loc_ReflectColor;
956         int loc_ReflectFactor;
957         int loc_ReflectOffset;
958 }
959 r_glsl_permutation_t;
960
961 // information about each possible shader permutation
962 r_glsl_permutation_t r_glsl_permutations[SHADERPERMUTATION_INDICES];
963 // currently selected permutation
964 r_glsl_permutation_t *r_glsl_permutation;
965
966 // these are additional flags used only by R_GLSL_CompilePermutation
967 #define SHADERTYPE_USES_VERTEXSHADER (1<<0)
968 #define SHADERTYPE_USES_GEOMETRYSHADER (1<<1)
969 #define SHADERTYPE_USES_FRAGMENTSHADER (1<<2)
970
971 static void R_GLSL_CompilePermutation(const char *filename, int permutation, int shadertype)
972 {
973         int i;
974         qboolean shaderfound;
975         r_glsl_permutation_t *p = r_glsl_permutations + permutation;
976         int vertstrings_count;
977         int geomstrings_count;
978         int fragstrings_count;
979         char *shaderstring;
980         const char *vertstrings_list[32+1];
981         const char *geomstrings_list[32+1];
982         const char *fragstrings_list[32+1];
983         char permutationname[256];
984         if (p->compiled)
985                 return;
986         p->compiled = true;
987         p->program = 0;
988         vertstrings_list[0] = "#define VERTEX_SHADER\n";
989         geomstrings_list[0] = "#define GEOMETRY_SHADER\n";
990         fragstrings_list[0] = "#define FRAGMENT_SHADER\n";
991         vertstrings_count = 1;
992         geomstrings_count = 1;
993         fragstrings_count = 1;
994         permutationname[0] = 0;
995         i = permutation / SHADERPERMUTATION_MODEBASE;
996         vertstrings_list[vertstrings_count++] = shadermodeinfo[i][0];
997         geomstrings_list[geomstrings_count++] = shadermodeinfo[i][0];
998         fragstrings_list[fragstrings_count++] = shadermodeinfo[i][0];
999         strlcat(permutationname, shadermodeinfo[i][1], sizeof(permutationname));
1000         for (i = 0;shaderpermutationinfo[i][0];i++)
1001         {
1002                 if (permutation & (1<<i))
1003                 {
1004                         vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i][0];
1005                         geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i][0];
1006                         fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i][0];
1007                         strlcat(permutationname, shaderpermutationinfo[i][1], sizeof(permutationname));
1008                 }
1009                 else
1010                 {
1011                         // keep line numbers correct
1012                         vertstrings_list[vertstrings_count++] = "\n";
1013                         geomstrings_list[geomstrings_count++] = "\n";
1014                         fragstrings_list[fragstrings_count++] = "\n";
1015                 }
1016         }
1017         shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
1018         shaderfound = false;
1019         if (shaderstring)
1020         {
1021                 Con_DPrint("from disk... ");
1022                 vertstrings_list[vertstrings_count++] = shaderstring;
1023                 geomstrings_list[geomstrings_count++] = shaderstring;
1024                 fragstrings_list[fragstrings_count++] = shaderstring;
1025                 shaderfound = true;
1026         }
1027         else if (!strcmp(filename, "glsl/default.glsl"))
1028         {
1029                 vertstrings_list[vertstrings_count++] = builtinshaderstring;
1030                 geomstrings_list[geomstrings_count++] = builtinshaderstring;
1031                 fragstrings_list[fragstrings_count++] = builtinshaderstring;
1032                 shaderfound = true;
1033         }
1034         // clear any lists that are not needed by this shader
1035         if (!(shadertype & SHADERTYPE_USES_VERTEXSHADER))
1036                 vertstrings_count = 0;
1037         if (!(shadertype & SHADERTYPE_USES_GEOMETRYSHADER))
1038                 geomstrings_count = 0;
1039         if (!(shadertype & SHADERTYPE_USES_FRAGMENTSHADER))
1040                 fragstrings_count = 0;
1041         // compile the shader program
1042         if (shaderfound && vertstrings_count + geomstrings_count + fragstrings_count)
1043                 p->program = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, geomstrings_count, geomstrings_list, fragstrings_count, fragstrings_list);
1044         if (p->program)
1045         {
1046                 CHECKGLERROR
1047                 qglUseProgramObjectARB(p->program);CHECKGLERROR
1048                 // look up all the uniform variable names we care about, so we don't
1049                 // have to look them up every time we set them
1050                 p->loc_Texture_Normal      = qglGetUniformLocationARB(p->program, "Texture_Normal");
1051                 p->loc_Texture_Color       = qglGetUniformLocationARB(p->program, "Texture_Color");
1052                 p->loc_Texture_Gloss       = qglGetUniformLocationARB(p->program, "Texture_Gloss");
1053                 p->loc_Texture_Cube        = qglGetUniformLocationARB(p->program, "Texture_Cube");
1054                 p->loc_Texture_Attenuation = qglGetUniformLocationARB(p->program, "Texture_Attenuation");
1055                 p->loc_Texture_FogMask     = qglGetUniformLocationARB(p->program, "Texture_FogMask");
1056                 p->loc_Texture_Pants       = qglGetUniformLocationARB(p->program, "Texture_Pants");
1057                 p->loc_Texture_Shirt       = qglGetUniformLocationARB(p->program, "Texture_Shirt");
1058                 p->loc_Texture_Lightmap    = qglGetUniformLocationARB(p->program, "Texture_Lightmap");
1059                 p->loc_Texture_Deluxemap   = qglGetUniformLocationARB(p->program, "Texture_Deluxemap");
1060                 p->loc_Texture_Glow        = qglGetUniformLocationARB(p->program, "Texture_Glow");
1061                 p->loc_Texture_Refraction  = qglGetUniformLocationARB(p->program, "Texture_Refraction");
1062                 p->loc_Texture_Reflection  = qglGetUniformLocationARB(p->program, "Texture_Reflection");
1063                 p->loc_FogColor            = qglGetUniformLocationARB(p->program, "FogColor");
1064                 p->loc_LightPosition       = qglGetUniformLocationARB(p->program, "LightPosition");
1065                 p->loc_EyePosition         = qglGetUniformLocationARB(p->program, "EyePosition");
1066                 p->loc_LightColor          = qglGetUniformLocationARB(p->program, "LightColor");
1067                 p->loc_Color_Pants         = qglGetUniformLocationARB(p->program, "Color_Pants");
1068                 p->loc_Color_Shirt         = qglGetUniformLocationARB(p->program, "Color_Shirt");
1069                 p->loc_FogRangeRecip       = qglGetUniformLocationARB(p->program, "FogRangeRecip");
1070                 p->loc_AmbientScale        = qglGetUniformLocationARB(p->program, "AmbientScale");
1071                 p->loc_DiffuseScale        = qglGetUniformLocationARB(p->program, "DiffuseScale");
1072                 p->loc_SpecularPower       = qglGetUniformLocationARB(p->program, "SpecularPower");
1073                 p->loc_SpecularScale       = qglGetUniformLocationARB(p->program, "SpecularScale");
1074                 p->loc_GlowScale           = qglGetUniformLocationARB(p->program, "GlowScale");
1075                 p->loc_SceneBrightness     = qglGetUniformLocationARB(p->program, "SceneBrightness");
1076                 p->loc_OffsetMapping_Scale = qglGetUniformLocationARB(p->program, "OffsetMapping_Scale");
1077                 p->loc_AmbientColor        = qglGetUniformLocationARB(p->program, "AmbientColor");
1078                 p->loc_DiffuseColor        = qglGetUniformLocationARB(p->program, "DiffuseColor");
1079                 p->loc_SpecularColor       = qglGetUniformLocationARB(p->program, "SpecularColor");
1080                 p->loc_LightDir            = qglGetUniformLocationARB(p->program, "LightDir");
1081                 p->loc_ContrastBoostCoeff  = qglGetUniformLocationARB(p->program, "ContrastBoostCoeff");
1082                 p->loc_DistortScaleRefractReflect = qglGetUniformLocationARB(p->program, "DistortScaleRefractReflect");
1083                 p->loc_ScreenScaleRefractReflect = qglGetUniformLocationARB(p->program, "ScreenScaleRefractReflect");
1084                 p->loc_ScreenCenterRefractReflect = qglGetUniformLocationARB(p->program, "ScreenCenterRefractReflect");
1085                 p->loc_RefractColor        = qglGetUniformLocationARB(p->program, "RefractColor");
1086                 p->loc_ReflectColor        = qglGetUniformLocationARB(p->program, "ReflectColor");
1087                 p->loc_ReflectFactor       = qglGetUniformLocationARB(p->program, "ReflectFactor");
1088                 p->loc_ReflectOffset       = qglGetUniformLocationARB(p->program, "ReflectOffset");
1089                 // initialize the samplers to refer to the texture units we use
1090                 if (p->loc_Texture_Normal >= 0)    qglUniform1iARB(p->loc_Texture_Normal, 0);
1091                 if (p->loc_Texture_Color >= 0)     qglUniform1iARB(p->loc_Texture_Color, 1);
1092                 if (p->loc_Texture_Gloss >= 0)     qglUniform1iARB(p->loc_Texture_Gloss, 2);
1093                 if (p->loc_Texture_Cube >= 0)      qglUniform1iARB(p->loc_Texture_Cube, 3);
1094                 if (p->loc_Texture_FogMask >= 0)   qglUniform1iARB(p->loc_Texture_FogMask, 4);
1095                 if (p->loc_Texture_Pants >= 0)     qglUniform1iARB(p->loc_Texture_Pants, 5);
1096                 if (p->loc_Texture_Shirt >= 0)     qglUniform1iARB(p->loc_Texture_Shirt, 6);
1097                 if (p->loc_Texture_Lightmap >= 0)  qglUniform1iARB(p->loc_Texture_Lightmap, 7);
1098                 if (p->loc_Texture_Deluxemap >= 0) qglUniform1iARB(p->loc_Texture_Deluxemap, 8);
1099                 if (p->loc_Texture_Glow >= 0)      qglUniform1iARB(p->loc_Texture_Glow, 9);
1100                 if (p->loc_Texture_Attenuation >= 0) qglUniform1iARB(p->loc_Texture_Attenuation, 10);
1101                 if (p->loc_Texture_Refraction >= 0) qglUniform1iARB(p->loc_Texture_Refraction, 11);
1102                 if (p->loc_Texture_Reflection >= 0) qglUniform1iARB(p->loc_Texture_Reflection, 12);
1103                 CHECKGLERROR
1104                 qglUseProgramObjectARB(0);CHECKGLERROR
1105                 if (developer.integer)
1106                         Con_Printf("GLSL shader %s :%s compiled.\n", filename, permutationname);
1107         }
1108         else
1109         {
1110                 if (developer.integer)
1111                         Con_Printf("GLSL shader %s :%s failed!  source code line offset for above errors is %i.\n", permutationname, filename, -(vertstrings_count - 1));
1112                 else
1113                         Con_Printf("GLSL shader %s :%s failed!  some features may not work properly.\n", permutationname, filename);
1114         }
1115         if (shaderstring)
1116                 Mem_Free(shaderstring);
1117 }
1118
1119 void R_GLSL_Restart_f(void)
1120 {
1121         int i;
1122         for (i = 0;i < SHADERPERMUTATION_INDICES;i++)
1123                 if (r_glsl_permutations[i].program)
1124                         GL_Backend_FreeProgram(r_glsl_permutations[i].program);
1125         memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
1126 }
1127
1128 void R_GLSL_DumpShader_f(void)
1129 {
1130         int i;
1131
1132         qfile_t *file = FS_Open("glsl/default.glsl", "w", false, false);
1133         if(!file)
1134         {
1135                 Con_Printf("failed to write to glsl/default.glsl\n");
1136                 return;
1137         }
1138
1139         FS_Print(file, "// The engine may define the following macros:\n");
1140         FS_Print(file, "// #define VERTEX_SHADER\n// #define GEOMETRY_SHADER\n// #define FRAGMENT_SHADER\n");
1141         for (i = 0;shadermodeinfo[i][0];i++)
1142                 FS_Printf(file, "// %s", shadermodeinfo[i][0]);
1143         for (i = 0;shaderpermutationinfo[i][0];i++)
1144                 FS_Printf(file, "// %s", shaderpermutationinfo[i][0]);
1145         FS_Print(file, "\n");
1146         FS_Print(file, builtinshaderstring);
1147         FS_Close(file);
1148
1149         Con_Printf("glsl/default.glsl written\n");
1150 }
1151
1152 extern rtexture_t *r_shadow_attenuationgradienttexture;
1153 extern rtexture_t *r_shadow_attenuation2dtexture;
1154 extern rtexture_t *r_shadow_attenuation3dtexture;
1155 int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass)
1156 {
1157         // select a permutation of the lighting shader appropriate to this
1158         // combination of texture, entity, light source, and fogging, only use the
1159         // minimum features necessary to avoid wasting rendering time in the
1160         // fragment shader on features that are not being used
1161         const char *shaderfilename = NULL;
1162         unsigned int permutation = 0;
1163         unsigned int shadertype = 0;
1164         shadermode_t mode = 0;
1165         r_glsl_permutation = NULL;
1166         shaderfilename = "glsl/default.glsl";
1167         shadertype = SHADERTYPE_USES_VERTEXSHADER | SHADERTYPE_USES_FRAGMENTSHADER;
1168         // TODO: implement geometry-shader based shadow volumes someday
1169         if (r_glsl_offsetmapping.integer)
1170         {
1171                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
1172                 if (r_glsl_offsetmapping_reliefmapping.integer)
1173                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
1174         }
1175         if (rsurfacepass == RSURFPASS_BACKGROUND)
1176         {
1177                 // distorted background
1178                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
1179                         mode = SHADERMODE_WATER;
1180                 else
1181                         mode = SHADERMODE_REFRACTION;
1182         }
1183         else if (rsurfacepass == RSURFPASS_RTLIGHT)
1184         {
1185                 // light source
1186                 mode = SHADERMODE_LIGHTSOURCE;
1187                 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
1188                         permutation |= SHADERPERMUTATION_CUBEFILTER;
1189                 if (diffusescale > 0)
1190                         permutation |= SHADERPERMUTATION_DIFFUSE;
1191                 if (specularscale > 0)
1192                         permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
1193                 if (r_refdef.fogenabled)
1194                         permutation |= SHADERPERMUTATION_FOG;
1195                 if (rsurface.texture->colormapping)
1196                         permutation |= SHADERPERMUTATION_COLORMAPPING;
1197                 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1198                         permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1199                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1200                         permutation |= SHADERPERMUTATION_REFLECTION;
1201         }
1202         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
1203         {
1204                 // bright unshaded geometry
1205                 mode = SHADERMODE_LIGHTMAP;
1206                 if (rsurface.texture->currentskinframe->glow)
1207                         permutation |= SHADERPERMUTATION_GLOW;
1208                 if (r_refdef.fogenabled)
1209                         permutation |= SHADERPERMUTATION_FOG;
1210                 if (rsurface.texture->colormapping)
1211                         permutation |= SHADERPERMUTATION_COLORMAPPING;
1212                 if (r_glsl_offsetmapping.integer)
1213                 {
1214                         permutation |= SHADERPERMUTATION_OFFSETMAPPING;
1215                         if (r_glsl_offsetmapping_reliefmapping.integer)
1216                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
1217                 }
1218                 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1219                         permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1220                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1221                         permutation |= SHADERPERMUTATION_REFLECTION;
1222         }
1223         else if (modellighting)
1224         {
1225                 // directional model lighting
1226                 mode = SHADERMODE_LIGHTDIRECTION;
1227                 if (rsurface.texture->currentskinframe->glow)
1228                         permutation |= SHADERPERMUTATION_GLOW;
1229                 if (specularscale > 0)
1230                         permutation |= SHADERPERMUTATION_SPECULAR;
1231                 if (r_refdef.fogenabled)
1232                         permutation |= SHADERPERMUTATION_FOG;
1233                 if (rsurface.texture->colormapping)
1234                         permutation |= SHADERPERMUTATION_COLORMAPPING;
1235                 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1236                         permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1237                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1238                         permutation |= SHADERPERMUTATION_REFLECTION;
1239         }
1240         else
1241         {
1242                 // lightmapped wall
1243                 if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping)
1244                 {
1245                         // deluxemapping (light direction texture)
1246                         if (rsurface.uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping && r_refdef.worldmodel->brushq3.deluxemapping_modelspace)
1247                                 mode = SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE;
1248                         else
1249                                 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
1250                         if (specularscale > 0)
1251                                 permutation |= SHADERPERMUTATION_SPECULAR;
1252                 }
1253                 else if (r_glsl_deluxemapping.integer >= 2)
1254                 {
1255                         // fake deluxemapping (uniform light direction in tangentspace)
1256                         mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
1257                         if (specularscale > 0)
1258                                 permutation |= SHADERPERMUTATION_SPECULAR;
1259                 }
1260                 else
1261                 {
1262                         // ordinary lightmapping
1263                         mode = SHADERMODE_LIGHTMAP;
1264                 }
1265                 if (rsurface.texture->currentskinframe->glow)
1266                         permutation |= SHADERPERMUTATION_GLOW;
1267                 if (r_refdef.fogenabled)
1268                         permutation |= SHADERPERMUTATION_FOG;
1269                 if (rsurface.texture->colormapping)
1270                         permutation |= SHADERPERMUTATION_COLORMAPPING;
1271                 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1272                         permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1273                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1274                         permutation |= SHADERPERMUTATION_REFLECTION;
1275         }
1276         permutation |= mode * SHADERPERMUTATION_MODEBASE;
1277         if (!r_glsl_permutations[permutation].program)
1278         {
1279                 if (!r_glsl_permutations[permutation].compiled)
1280                         R_GLSL_CompilePermutation(shaderfilename, permutation, shadertype);
1281                 if (!r_glsl_permutations[permutation].program)
1282                 {
1283                         // remove features until we find a valid permutation
1284                         unsigned int i;
1285                         for (i = (SHADERPERMUTATION_MODEBASE >> 1);;i>>=1)
1286                         {
1287                                 if (!i)
1288                                 {
1289                                         Con_Printf("OpenGL 2.0 shaders disabled - unable to find a working shader permutation fallback on this driver (set r_glsl 1 if you want to try again)\n");
1290                                         Cvar_SetValueQuick(&r_glsl, 0);
1291                                         return 0; // no bit left to clear
1292                                 }
1293                                 // reduce i more quickly whenever it would not remove any bits
1294                                 if (!(permutation & i))
1295                                         continue;
1296                                 permutation &= ~i;
1297                                 if (!r_glsl_permutations[permutation].compiled)
1298                                         R_GLSL_CompilePermutation(shaderfilename, permutation, shadertype);
1299                                 if (r_glsl_permutations[permutation].program)
1300                                         break;
1301                         }
1302                 }
1303         }
1304         r_glsl_permutation = r_glsl_permutations + permutation;
1305         CHECKGLERROR
1306         qglUseProgramObjectARB(r_glsl_permutation->program);CHECKGLERROR
1307         if (mode == SHADERMODE_LIGHTSOURCE)
1308         {
1309                 if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
1310                 if (permutation & SHADERPERMUTATION_DIFFUSE)
1311                 {
1312                         if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
1313                         if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, ambientscale);
1314                         if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, diffusescale);
1315                         if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, specularscale);
1316                 }
1317                 else
1318                 {
1319                         // ambient only is simpler
1320                         if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0] * ambientscale, lightcolorbase[1] * ambientscale, lightcolorbase[2] * ambientscale);
1321                         if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, 1);
1322                         if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, 0);
1323                         if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, 0);
1324                 }
1325         }
1326         else if (mode == SHADERMODE_LIGHTDIRECTION)
1327         {
1328                 if (r_glsl_permutation->loc_AmbientColor >= 0)
1329                         qglUniform3fARB(r_glsl_permutation->loc_AmbientColor, rsurface.modellight_ambient[0] * ambientscale, rsurface.modellight_ambient[1] * ambientscale, rsurface.modellight_ambient[2] * ambientscale);
1330                 if (r_glsl_permutation->loc_DiffuseColor >= 0)
1331                         qglUniform3fARB(r_glsl_permutation->loc_DiffuseColor, rsurface.modellight_diffuse[0] * diffusescale, rsurface.modellight_diffuse[1] * diffusescale, rsurface.modellight_diffuse[2] * diffusescale);
1332                 if (r_glsl_permutation->loc_SpecularColor >= 0)
1333                         qglUniform3fARB(r_glsl_permutation->loc_SpecularColor, rsurface.modellight_diffuse[0] * specularscale, rsurface.modellight_diffuse[1] * specularscale, rsurface.modellight_diffuse[2] * specularscale);
1334                 if (r_glsl_permutation->loc_LightDir >= 0)
1335                         qglUniform3fARB(r_glsl_permutation->loc_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
1336         }
1337         else
1338         {
1339                 if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, r_ambient.value * 2.0f / 128.0f);
1340                 if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, r_refdef.lightmapintensity * 2.0f);
1341                 if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, r_refdef.lightmapintensity * specularscale * 2.0f);
1342         }
1343         if (r_glsl_permutation->loc_GlowScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_GlowScale, r_hdr_glowintensity.value);
1344         if (r_glsl_permutation->loc_ContrastBoostCoeff >= 0)
1345         {
1346                 // The formula used is actually:
1347                 //   color.rgb *= SceneBrightness;
1348                 //   color.rgb *= ContrastBoost / ((ContrastBoost - 1) * color.rgb + 1);
1349                 // I simplify that to
1350                 //   color.rgb *= [[SceneBrightness * ContrastBoost]];
1351                 //   color.rgb /= [[(ContrastBoost - 1) / ContrastBoost]] * color.rgb + 1;
1352                 // and Black:
1353                 //   color.rgb = [[SceneBrightness * ContrastBoost]] / ([[(ContrastBoost - 1) * SceneBrightness]] + 1 / color.rgb);
1354                 // and do [[calculations]] here in the engine
1355                 qglUniform1fARB(r_glsl_permutation->loc_ContrastBoostCoeff, (r_glsl_contrastboost.value - 1) * r_view.colorscale);
1356                 if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale * r_glsl_contrastboost.value);
1357         }
1358         else
1359                 if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale);
1360         if (r_glsl_permutation->loc_FogColor >= 0)
1361         {
1362                 // additive passes are only darkened by fog, not tinted
1363                 if (rsurface.rtlight || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD))
1364                         qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
1365                 else
1366                         qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
1367         }
1368         if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.modelorg[0], rsurface.modelorg[1], rsurface.modelorg[2]);
1369         if (r_glsl_permutation->loc_Color_Pants >= 0)
1370         {
1371                 if (rsurface.texture->currentskinframe->pants)
1372                         qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
1373                 else
1374                         qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, 0, 0, 0);
1375         }
1376         if (r_glsl_permutation->loc_Color_Shirt >= 0)
1377         {
1378                 if (rsurface.texture->currentskinframe->shirt)
1379                         qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
1380                 else
1381                         qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
1382         }
1383         if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, r_refdef.fograngerecip);
1384         if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower);
1385         if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);
1386         if (r_glsl_permutation->loc_DistortScaleRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_DistortScaleRefractReflect, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor);
1387         if (r_glsl_permutation->loc_ScreenScaleRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_ScreenScaleRefractReflect, r_waterstate.screenscale[0], r_waterstate.screenscale[1], r_waterstate.screenscale[0], r_waterstate.screenscale[1]);
1388         if (r_glsl_permutation->loc_ScreenCenterRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_ScreenCenterRefractReflect, r_waterstate.screencenter[0], r_waterstate.screencenter[1], r_waterstate.screencenter[0], r_waterstate.screencenter[1]);
1389         if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_RefractColor, 1, rsurface.texture->refractcolor4f);
1390         if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_ReflectColor, 1, rsurface.texture->reflectcolor4f);
1391         if (r_glsl_permutation->loc_ReflectFactor >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
1392         if (r_glsl_permutation->loc_ReflectOffset >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectOffset, rsurface.texture->reflectmin);
1393         CHECKGLERROR
1394         return permutation;
1395 }
1396
1397 #define SKINFRAME_HASH 1024
1398
1399 struct
1400 {
1401         int loadsequence; // incremented each level change
1402         memexpandablearray_t array;
1403         skinframe_t *hash[SKINFRAME_HASH];
1404 }
1405 r_skinframe;
1406
1407 void R_SkinFrame_PrepareForPurge(void)
1408 {
1409         r_skinframe.loadsequence++;
1410         // wrap it without hitting zero
1411         if (r_skinframe.loadsequence >= 200)
1412                 r_skinframe.loadsequence = 1;
1413 }
1414
1415 void R_SkinFrame_MarkUsed(skinframe_t *skinframe)
1416 {
1417         if (!skinframe)
1418                 return;
1419         // mark the skinframe as used for the purging code
1420         skinframe->loadsequence = r_skinframe.loadsequence;
1421 }
1422
1423 void R_SkinFrame_Purge(void)
1424 {
1425         int i;
1426         skinframe_t *s;
1427         for (i = 0;i < SKINFRAME_HASH;i++)
1428         {
1429                 for (s = r_skinframe.hash[i];s;s = s->next)
1430                 {
1431                         if (s->loadsequence && s->loadsequence != r_skinframe.loadsequence)
1432                         {
1433                                 if (s->base == r_texture_notexture)     s->base   = NULL;
1434                                 if (s->nmap == r_texture_blanknormalmap)s->nmap   = NULL;
1435                                 if (s->merged == s->base)               s->merged = NULL;
1436                                 if (s->stain ) R_FreeTexture(s->stain );s->stain  = NULL;
1437                                 if (s->merged) R_FreeTexture(s->merged);s->merged = NULL;
1438                                 if (s->base  ) R_FreeTexture(s->base  );s->base   = NULL;
1439                                 if (s->pants ) R_FreeTexture(s->pants );s->pants  = NULL;
1440                                 if (s->shirt ) R_FreeTexture(s->shirt );s->shirt  = NULL;
1441                                 if (s->nmap  ) R_FreeTexture(s->nmap  );s->nmap   = NULL;
1442                                 if (s->gloss ) R_FreeTexture(s->gloss );s->gloss  = NULL;
1443                                 if (s->glow  ) R_FreeTexture(s->glow  );s->glow   = NULL;
1444                                 if (s->fog   ) R_FreeTexture(s->fog   );s->fog    = NULL;
1445                                 s->loadsequence = 0;
1446                         }
1447                 }
1448         }
1449 }
1450
1451 skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qboolean add)
1452 {
1453         skinframe_t *item;
1454         int hashindex;
1455         char basename[MAX_QPATH];
1456
1457         Image_StripImageExtension(name, basename, sizeof(basename));
1458
1459         hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
1460         for (item = r_skinframe.hash[hashindex];item;item = item->next)
1461                 if (!strcmp(item->basename, basename) && item->textureflags == textureflags && item->comparewidth == comparewidth && item->compareheight == compareheight && item->comparecrc == comparecrc)
1462                         break;
1463         if (!item)
1464         {
1465                 if (!add)
1466                         return NULL;
1467                 item = (skinframe_t *)Mem_ExpandableArray_AllocRecord(&r_skinframe.array);
1468                 memset(item, 0, sizeof(*item));
1469                 strlcpy(item->basename, basename, sizeof(item->basename));
1470                 item->textureflags = textureflags;
1471                 item->comparewidth = comparewidth;
1472                 item->compareheight = compareheight;
1473                 item->comparecrc = comparecrc;
1474                 item->next = r_skinframe.hash[hashindex];
1475                 r_skinframe.hash[hashindex] = item;
1476         }
1477         R_SkinFrame_MarkUsed(item);
1478         return item;
1479 }
1480
1481 skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain)
1482 {
1483         // FIXME: it should be possible to disable loading various layers using
1484         // cvars, to prevent wasted loading time and memory usage if the user does
1485         // not want them
1486         qboolean loadnormalmap = true;
1487         qboolean loadgloss = true;
1488         qboolean loadpantsandshirt = true;
1489         qboolean loadglow = true;
1490         int j;
1491         unsigned char *pixels;
1492         unsigned char *bumppixels;
1493         unsigned char *basepixels = NULL;
1494         int basepixels_width;
1495         int basepixels_height;
1496         skinframe_t *skinframe;
1497
1498         if (cls.state == ca_dedicated)
1499                 return NULL;
1500
1501         // return an existing skinframe if already loaded
1502         // if loading of the first image fails, don't make a new skinframe as it
1503         // would cause all future lookups of this to be missing
1504         skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
1505         if (skinframe && skinframe->base)
1506                 return skinframe;
1507
1508         basepixels = loadimagepixels(name, complain, 0, 0);
1509         if (basepixels == NULL)
1510                 return NULL;
1511
1512         // we've got some pixels to store, so really allocate this new texture now
1513         if (!skinframe)
1514                 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, true);
1515         skinframe->stain = NULL;
1516         skinframe->merged = NULL;
1517         skinframe->base = r_texture_notexture;
1518         skinframe->pants = NULL;
1519         skinframe->shirt = NULL;
1520         skinframe->nmap = r_texture_blanknormalmap;
1521         skinframe->gloss = NULL;
1522         skinframe->glow = NULL;
1523         skinframe->fog = NULL;
1524
1525         basepixels_width = image_width;
1526         basepixels_height = image_height;
1527         skinframe->base = R_LoadTexture2D (r_main_texturepool, skinframe->basename, basepixels_width, basepixels_height, basepixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);
1528
1529         if (textureflags & TEXF_ALPHA)
1530         {
1531                 for (j = 3;j < basepixels_width * basepixels_height * 4;j += 4)
1532                         if (basepixels[j] < 255)
1533                                 break;
1534                 if (j < basepixels_width * basepixels_height * 4)
1535                 {
1536                         // has transparent pixels
1537                         pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
1538                         for (j = 0;j < image_width * image_height * 4;j += 4)
1539                         {
1540                                 pixels[j+0] = 255;
1541                                 pixels[j+1] = 255;
1542                                 pixels[j+2] = 255;
1543                                 pixels[j+3] = basepixels[j+3];
1544                         }
1545                         skinframe->fog = R_LoadTexture2D (r_main_texturepool, va("%s_mask", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);
1546                         Mem_Free(pixels);
1547                 }
1548         }
1549
1550         // _norm is the name used by tenebrae and has been adopted as standard
1551         if (loadnormalmap)
1552         {
1553                 if ((pixels = loadimagepixels(va("%s_norm", skinframe->basename), false, 0, 0)) != NULL)
1554                 {
1555                         skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
1556                         Mem_Free(pixels);
1557                         pixels = NULL;
1558                 }
1559                 else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixels(va("%s_bump", skinframe->basename), false, 0, 0)) != NULL)
1560                 {
1561                         pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
1562                         Image_HeightmapToNormalmap(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value);
1563                         skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
1564                         Mem_Free(pixels);
1565                         Mem_Free(bumppixels);
1566                 }
1567                 else if (r_shadow_bumpscale_basetexture.value > 0)
1568                 {
1569                         pixels = (unsigned char *)Mem_Alloc(tempmempool, basepixels_width * basepixels_height * 4);
1570                         Image_HeightmapToNormalmap(basepixels, pixels, basepixels_width, basepixels_height, false, r_shadow_bumpscale_basetexture.value);
1571                         skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), basepixels_width, basepixels_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
1572                         Mem_Free(pixels);
1573                 }
1574         }
1575         // _luma is supported for tenebrae compatibility
1576         // (I think it's a very stupid name, but oh well)
1577         // _glow is the preferred name
1578         if (loadglow          && ((pixels = loadimagepixels(va("%s_glow", skinframe->basename), false, 0, 0)) != NULL || (pixels = loadimagepixels(va("%s_luma", skinframe->basename), false, 0, 0)) != NULL)) {skinframe->glow = R_LoadTexture2D (r_main_texturepool, va("%s_glow", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_glow.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
1579         if (loadgloss         && (pixels = loadimagepixels(va("%s_gloss", skinframe->basename), false, 0, 0)) != NULL) {skinframe->gloss = R_LoadTexture2D (r_main_texturepool, va("%s_gloss", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_gloss.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
1580         if (loadpantsandshirt && (pixels = loadimagepixels(va("%s_pants", skinframe->basename), false, 0, 0)) != NULL) {skinframe->pants = R_LoadTexture2D (r_main_texturepool, va("%s_pants", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
1581         if (loadpantsandshirt && (pixels = loadimagepixels(va("%s_shirt", skinframe->basename), false, 0, 0)) != NULL) {skinframe->shirt = R_LoadTexture2D (r_main_texturepool, va("%s_shirt", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
1582
1583         if (basepixels)
1584                 Mem_Free(basepixels);
1585
1586         return skinframe;
1587 }
1588
1589 static rtexture_t *R_SkinFrame_TextureForSkinLayer(const unsigned char *in, int width, int height, const char *name, const unsigned int *palette, int textureflags, qboolean force)
1590 {
1591         int i;
1592         if (!force)
1593         {
1594                 for (i = 0;i < width*height;i++)
1595                         if (((unsigned char *)&palette[in[i]])[3] > 0)
1596                                 break;
1597                 if (i == width*height)
1598                         return NULL;
1599         }
1600         return R_LoadTexture2D (r_main_texturepool, name, width, height, in, TEXTYPE_PALETTE, textureflags, palette);
1601 }
1602
1603 skinframe_t *R_SkinFrame_LoadInternal(const char *name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height, int bitsperpixel, const unsigned int *palette, const unsigned int *alphapalette)
1604 {
1605         int i;
1606         unsigned char *temp1, *temp2;
1607         skinframe_t *skinframe;
1608
1609         if (cls.state == ca_dedicated)
1610                 return NULL;
1611
1612         // if already loaded just return it, otherwise make a new skinframe
1613         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height*bitsperpixel/8) : 0, true);
1614         if (skinframe && skinframe->base)
1615                 return skinframe;
1616
1617         skinframe->stain = NULL;
1618         skinframe->merged = NULL;
1619         skinframe->base = r_texture_notexture;
1620         skinframe->pants = NULL;
1621         skinframe->shirt = NULL;
1622         skinframe->nmap = r_texture_blanknormalmap;
1623         skinframe->gloss = NULL;
1624         skinframe->glow = NULL;
1625         skinframe->fog = NULL;
1626
1627         // if no data was provided, then clearly the caller wanted to get a blank skinframe
1628         if (!skindata)
1629                 return NULL;
1630
1631         if (bitsperpixel == 32)
1632         {
1633                 if (r_shadow_bumpscale_basetexture.value > 0)
1634                 {
1635                         temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
1636                         temp2 = temp1 + width * height * 4;
1637                         Image_HeightmapToNormalmap(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
1638                         skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_RGBA, skinframe->textureflags | TEXF_ALPHA, NULL);
1639                         Mem_Free(temp1);
1640                 }
1641                 skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_RGBA, skinframe->textureflags, NULL);
1642                 if (textureflags & TEXF_ALPHA)
1643                 {
1644                         for (i = 3;i < width * height * 4;i += 4)
1645                                 if (skindata[i] < 255)
1646                                         break;
1647                         if (i < width * height * 4)
1648                         {
1649                                 unsigned char *fogpixels = (unsigned char *)Mem_Alloc(tempmempool, width * height * 4);
1650                                 memcpy(fogpixels, skindata, width * height * 4);
1651                                 for (i = 0;i < width * height * 4;i += 4)
1652                                         fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
1653                                 skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_RGBA, skinframe->textureflags, NULL);
1654                                 Mem_Free(fogpixels);
1655                         }
1656                 }
1657         }
1658         else if (bitsperpixel == 8)
1659         {
1660                 if (r_shadow_bumpscale_basetexture.value > 0)
1661                 {
1662                         temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
1663                         temp2 = temp1 + width * height * 4;
1664                         if (bitsperpixel == 32)
1665                                 Image_HeightmapToNormalmap(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
1666                         else
1667                         {
1668                                 // use either a custom palette or the quake palette
1669                                 Image_Copy8bitRGBA(skindata, temp1, width * height, palette ? palette : palette_complete);
1670                                 Image_HeightmapToNormalmap(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
1671                         }
1672                         skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_RGBA, skinframe->textureflags | TEXF_ALPHA, NULL);
1673                         Mem_Free(temp1);
1674                 }
1675                 // use either a custom palette, or the quake palette
1676                 skinframe->base = skinframe->merged = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_merged", skinframe->basename), palette ? palette : (loadglowtexture ? palette_nofullbrights : ((skinframe->textureflags & TEXF_ALPHA) ? palette_transparent : palette_complete)), skinframe->textureflags, true); // all
1677                 if (!palette && loadglowtexture)
1678                         skinframe->glow = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_glow", skinframe->basename), palette_onlyfullbrights, skinframe->textureflags, false); // glow
1679                 if (!palette && loadpantsandshirt)
1680                 {
1681                         skinframe->pants = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_pants", skinframe->basename), palette_pantsaswhite, skinframe->textureflags, false); // pants
1682                         skinframe->shirt = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_shirt", skinframe->basename), palette_shirtaswhite, skinframe->textureflags, false); // shirt
1683                 }
1684                 if (skinframe->pants || skinframe->shirt)
1685                         skinframe->base = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_nospecial", skinframe->basename),loadglowtexture ? palette_nocolormapnofullbrights : palette_nocolormap, skinframe->textureflags, false); // no special colors
1686                 if (textureflags & TEXF_ALPHA)
1687                 {
1688                         // if not using a custom alphapalette, use the quake one
1689                         if (!alphapalette)
1690                                 alphapalette = palette_alpha;
1691                         for (i = 0;i < width * height;i++)
1692                                 if (((unsigned char *)alphapalette)[skindata[i]*4+3] < 255)
1693                                         break;
1694                         if (i < width * height)
1695                                 skinframe->fog = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_fog", skinframe->basename), alphapalette, skinframe->textureflags, true); // fog mask
1696                 }
1697         }
1698
1699         return skinframe;
1700 }
1701
1702 skinframe_t *R_SkinFrame_LoadMissing(void)
1703 {
1704         skinframe_t *skinframe;
1705
1706         if (cls.state == ca_dedicated)
1707                 return NULL;
1708
1709         skinframe = R_SkinFrame_Find("missing", TEXF_PRECACHE, 0, 0, 0, true);
1710         skinframe->stain = NULL;
1711         skinframe->merged = NULL;
1712         skinframe->base = r_texture_notexture;
1713         skinframe->pants = NULL;
1714         skinframe->shirt = NULL;
1715         skinframe->nmap = r_texture_blanknormalmap;
1716         skinframe->gloss = NULL;
1717         skinframe->glow = NULL;
1718         skinframe->fog = NULL;
1719
1720         return skinframe;
1721 }
1722
1723 void gl_main_start(void)
1724 {
1725         int x;
1726         double r, alpha;
1727
1728         r = (-1.0/256.0) * (FOGMASKTABLEWIDTH * FOGMASKTABLEWIDTH);
1729         for (x = 0;x < FOGMASKTABLEWIDTH;x++)
1730         {
1731                 alpha = 1 - exp(r / ((double)x*(double)x));
1732                 if (x == FOGMASKTABLEWIDTH - 1)
1733                         alpha = 0;
1734                 r_refdef.fogmasktable[x] = bound(0, alpha, 1);
1735         }
1736
1737         memset(r_qwskincache, 0, sizeof(r_qwskincache));
1738         memset(r_qwskincache_skinframe, 0, sizeof(r_qwskincache_skinframe));
1739
1740         // set up r_skinframe loading system for textures
1741         memset(&r_skinframe, 0, sizeof(r_skinframe));
1742         r_skinframe.loadsequence = 1;
1743         Mem_ExpandableArray_NewArray(&r_skinframe.array, r_main_mempool, sizeof(skinframe_t), 256);
1744
1745         r_main_texturepool = R_AllocTexturePool();
1746         R_BuildBlankTextures();
1747         R_BuildNoTexture();
1748         if (gl_texturecubemap)
1749         {
1750                 R_BuildWhiteCube();
1751                 R_BuildNormalizationCube();
1752         }
1753         R_BuildFogTexture();
1754         memset(&r_bloomstate, 0, sizeof(r_bloomstate));
1755         memset(&r_waterstate, 0, sizeof(r_waterstate));
1756         memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
1757         memset(&r_svbsp, 0, sizeof (r_svbsp));
1758 }
1759
1760 void gl_main_shutdown(void)
1761 {
1762         memset(r_qwskincache, 0, sizeof(r_qwskincache));
1763         memset(r_qwskincache_skinframe, 0, sizeof(r_qwskincache_skinframe));
1764
1765         // clear out the r_skinframe state
1766         Mem_ExpandableArray_FreeArray(&r_skinframe.array);
1767         memset(&r_skinframe, 0, sizeof(r_skinframe));
1768
1769         if (r_svbsp.nodes)
1770                 Mem_Free(r_svbsp.nodes);
1771         memset(&r_svbsp, 0, sizeof (r_svbsp));
1772         R_FreeTexturePool(&r_main_texturepool);
1773         r_texture_blanknormalmap = NULL;
1774         r_texture_white = NULL;
1775         r_texture_grey128 = NULL;
1776         r_texture_black = NULL;
1777         r_texture_whitecube = NULL;
1778         r_texture_normalizationcube = NULL;
1779         memset(&r_bloomstate, 0, sizeof(r_bloomstate));
1780         memset(&r_waterstate, 0, sizeof(r_waterstate));
1781         R_GLSL_Restart_f();
1782 }
1783
1784 extern void CL_ParseEntityLump(char *entitystring);
1785 void gl_main_newmap(void)
1786 {
1787         // FIXME: move this code to client
1788         int l;
1789         char *entities, entname[MAX_QPATH];
1790         if (cl.worldmodel)
1791         {
1792                 strlcpy(entname, cl.worldmodel->name, sizeof(entname));
1793                 l = (int)strlen(entname) - 4;
1794                 if (l >= 0 && !strcmp(entname + l, ".bsp"))
1795                 {
1796                         memcpy(entname + l, ".ent", 5);
1797                         if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
1798                         {
1799                                 CL_ParseEntityLump(entities);
1800                                 Mem_Free(entities);
1801                                 return;
1802                         }
1803                 }
1804                 if (cl.worldmodel->brush.entities)
1805                         CL_ParseEntityLump(cl.worldmodel->brush.entities);
1806         }
1807 }
1808
1809 void GL_Main_Init(void)
1810 {
1811         r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
1812
1813         Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed");
1814         Cmd_AddCommand("r_glsl_dumpshader", R_GLSL_DumpShader_f, "dumps the engine internal default.glsl shader into glsl/default.glsl");
1815         // FIXME: the client should set up r_refdef.fog stuff including the fogmasktable
1816         if (gamemode == GAME_NEHAHRA)
1817         {
1818                 Cvar_RegisterVariable (&gl_fogenable);
1819                 Cvar_RegisterVariable (&gl_fogdensity);
1820                 Cvar_RegisterVariable (&gl_fogred);
1821                 Cvar_RegisterVariable (&gl_foggreen);
1822                 Cvar_RegisterVariable (&gl_fogblue);
1823                 Cvar_RegisterVariable (&gl_fogstart);
1824                 Cvar_RegisterVariable (&gl_fogend);
1825         }
1826         Cvar_RegisterVariable(&r_depthfirst);
1827         Cvar_RegisterVariable(&r_nearclip);
1828         Cvar_RegisterVariable(&r_showbboxes);
1829         Cvar_RegisterVariable(&r_showsurfaces);
1830         Cvar_RegisterVariable(&r_showtris);
1831         Cvar_RegisterVariable(&r_shownormals);
1832         Cvar_RegisterVariable(&r_showlighting);
1833         Cvar_RegisterVariable(&r_showshadowvolumes);
1834         Cvar_RegisterVariable(&r_showcollisionbrushes);
1835         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
1836         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
1837         Cvar_RegisterVariable(&r_showdisabledepthtest);
1838         Cvar_RegisterVariable(&r_drawportals);
1839         Cvar_RegisterVariable(&r_drawentities);
1840         Cvar_RegisterVariable(&r_cullentities_trace);
1841         Cvar_RegisterVariable(&r_cullentities_trace_samples);
1842         Cvar_RegisterVariable(&r_cullentities_trace_enlarge);
1843         Cvar_RegisterVariable(&r_cullentities_trace_delay);
1844         Cvar_RegisterVariable(&r_drawviewmodel);
1845         Cvar_RegisterVariable(&r_speeds);
1846         Cvar_RegisterVariable(&r_fullbrights);
1847         Cvar_RegisterVariable(&r_wateralpha);
1848         Cvar_RegisterVariable(&r_dynamic);
1849         Cvar_RegisterVariable(&r_fullbright);
1850         Cvar_RegisterVariable(&r_shadows);
1851         Cvar_RegisterVariable(&r_shadows_throwdistance);
1852         Cvar_RegisterVariable(&r_q1bsp_skymasking);
1853         Cvar_RegisterVariable(&r_polygonoffset_submodel_factor);
1854         Cvar_RegisterVariable(&r_polygonoffset_submodel_offset);
1855         Cvar_RegisterVariable(&r_textureunits);
1856         Cvar_RegisterVariable(&r_glsl);
1857         Cvar_RegisterVariable(&r_glsl_offsetmapping);
1858         Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
1859         Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
1860         Cvar_RegisterVariable(&r_glsl_deluxemapping);
1861         Cvar_RegisterVariable(&r_water);
1862         Cvar_RegisterVariable(&r_water_resolutionmultiplier);
1863         Cvar_RegisterVariable(&r_water_clippingplanebias);
1864         Cvar_RegisterVariable(&r_water_refractdistort);
1865         Cvar_RegisterVariable(&r_water_reflectdistort);
1866         Cvar_RegisterVariable(&r_lerpsprites);
1867         Cvar_RegisterVariable(&r_lerpmodels);
1868         Cvar_RegisterVariable(&r_waterscroll);
1869         Cvar_RegisterVariable(&r_bloom);
1870         Cvar_RegisterVariable(&r_bloom_colorscale);
1871         Cvar_RegisterVariable(&r_bloom_brighten);
1872         Cvar_RegisterVariable(&r_bloom_blur);
1873         Cvar_RegisterVariable(&r_bloom_resolution);
1874         Cvar_RegisterVariable(&r_bloom_colorexponent);
1875         Cvar_RegisterVariable(&r_bloom_colorsubtract);
1876         Cvar_RegisterVariable(&r_hdr);
1877         Cvar_RegisterVariable(&r_hdr_scenebrightness);
1878         Cvar_RegisterVariable(&r_glsl_contrastboost);
1879         Cvar_RegisterVariable(&r_hdr_glowintensity);
1880         Cvar_RegisterVariable(&r_hdr_range);
1881         Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
1882         Cvar_RegisterVariable(&developer_texturelogging);
1883         Cvar_RegisterVariable(&gl_lightmaps);
1884         Cvar_RegisterVariable(&r_test);
1885         Cvar_RegisterVariable(&r_batchmode);
1886         if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
1887                 Cvar_SetValue("r_fullbrights", 0);
1888         R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap);
1889 }
1890
1891 extern void R_Textures_Init(void);
1892 extern void GL_Draw_Init(void);
1893 extern void GL_Main_Init(void);
1894 extern void R_Shadow_Init(void);
1895 extern void R_Sky_Init(void);
1896 extern void GL_Surf_Init(void);
1897 extern void R_Light_Init(void);
1898 extern void R_Particles_Init(void);
1899 extern void R_Explosion_Init(void);
1900 extern void gl_backend_init(void);
1901 extern void Sbar_Init(void);
1902 extern void R_LightningBeams_Init(void);
1903 extern void Mod_RenderInit(void);
1904
1905 void Render_Init(void)
1906 {
1907         gl_backend_init();
1908         R_Textures_Init();
1909         GL_Main_Init();
1910         GL_Draw_Init();
1911         R_Shadow_Init();
1912         R_Sky_Init();
1913         GL_Surf_Init();
1914         Sbar_Init();
1915         R_Light_Init();
1916         R_Particles_Init();
1917         R_Explosion_Init();
1918         R_LightningBeams_Init();
1919         Mod_RenderInit();
1920 }
1921
1922 /*
1923 ===============
1924 GL_Init
1925 ===============
1926 */
1927 extern char *ENGINE_EXTENSIONS;
1928 void GL_Init (void)
1929 {
1930         VID_CheckExtensions();
1931
1932         // LordHavoc: report supported extensions
1933         Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
1934
1935         // clear to black (loading plaque will be seen over this)
1936         CHECKGLERROR
1937         qglClearColor(0,0,0,1);CHECKGLERROR
1938         qglClear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
1939 }
1940
1941 int R_CullBox(const vec3_t mins, const vec3_t maxs)
1942 {
1943         int i;
1944         mplane_t *p;
1945         for (i = 0;i < r_view.numfrustumplanes;i++)
1946         {
1947                 // skip nearclip plane, it often culls portals when you are very close, and is almost never useful
1948                 if (i == 4)
1949                         continue;
1950                 p = r_view.frustum + i;
1951                 switch(p->signbits)
1952                 {
1953                 default:
1954                 case 0:
1955                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
1956                                 return true;
1957                         break;
1958                 case 1:
1959                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
1960                                 return true;
1961                         break;
1962                 case 2:
1963                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
1964                                 return true;
1965                         break;
1966                 case 3:
1967                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
1968                                 return true;
1969                         break;
1970                 case 4:
1971                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
1972                                 return true;
1973                         break;
1974                 case 5:
1975                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
1976                                 return true;
1977                         break;
1978                 case 6:
1979                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
1980                                 return true;
1981                         break;
1982                 case 7:
1983                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
1984                                 return true;
1985                         break;
1986                 }
1987         }
1988         return false;
1989 }
1990
1991 int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes)
1992 {
1993         int i;
1994         const mplane_t *p;
1995         for (i = 0;i < numplanes;i++)
1996         {
1997                 p = planes + i;
1998                 switch(p->signbits)
1999                 {
2000                 default:
2001                 case 0:
2002                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2003                                 return true;
2004                         break;
2005                 case 1:
2006                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2007                                 return true;
2008                         break;
2009                 case 2:
2010                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2011                                 return true;
2012                         break;
2013                 case 3:
2014                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2015                                 return true;
2016                         break;
2017                 case 4:
2018                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2019                                 return true;
2020                         break;
2021                 case 5:
2022                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2023                                 return true;
2024                         break;
2025                 case 6:
2026                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2027                                 return true;
2028                         break;
2029                 case 7:
2030                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2031                                 return true;
2032                         break;
2033                 }
2034         }
2035         return false;
2036 }
2037
2038 //==================================================================================
2039
2040 static void R_UpdateEntityLighting(entity_render_t *ent)
2041 {
2042         vec3_t tempdiffusenormal;
2043
2044         // fetch the lighting from the worldmodel data
2045         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));
2046         VectorClear(ent->modellight_diffuse);
2047         VectorClear(tempdiffusenormal);
2048         if ((ent->flags & RENDER_LIGHT) && r_refdef.worldmodel && r_refdef.worldmodel->brush.LightPoint)
2049         {
2050                 vec3_t org;
2051                 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
2052                 r_refdef.worldmodel->brush.LightPoint(r_refdef.worldmodel, org, ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal);
2053         }
2054         else // highly rare
2055                 VectorSet(ent->modellight_ambient, 1, 1, 1);
2056
2057         // move the light direction into modelspace coordinates for lighting code
2058         Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, ent->modellight_lightdir);
2059         if(VectorLength2(ent->modellight_lightdir) > 0)
2060         {
2061                 VectorNormalize(ent->modellight_lightdir);
2062         }
2063         else
2064         {
2065                 VectorSet(ent->modellight_lightdir, 0, 0, 1); // have to set SOME valid vector here
2066         }
2067
2068         // scale ambient and directional light contributions according to rendering variables
2069         ent->modellight_ambient[0] *= ent->colormod[0] * r_refdef.lightmapintensity;
2070         ent->modellight_ambient[1] *= ent->colormod[1] * r_refdef.lightmapintensity;
2071         ent->modellight_ambient[2] *= ent->colormod[2] * r_refdef.lightmapintensity;
2072         ent->modellight_diffuse[0] *= ent->colormod[0] * r_refdef.lightmapintensity;
2073         ent->modellight_diffuse[1] *= ent->colormod[1] * r_refdef.lightmapintensity;
2074         ent->modellight_diffuse[2] *= ent->colormod[2] * r_refdef.lightmapintensity;
2075 }
2076
2077 static void R_View_UpdateEntityVisible (void)
2078 {
2079         int i, renderimask;
2080         entity_render_t *ent;
2081
2082         if (!r_drawentities.integer)
2083                 return;
2084
2085         renderimask = r_refdef.envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL) : ((chase_active.integer || r_waterstate.renderingscene) ? RENDER_VIEWMODEL : RENDER_EXTERIORMODEL);
2086         if (r_refdef.worldmodel && r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs)
2087         {
2088                 // worldmodel can check visibility
2089                 for (i = 0;i < r_refdef.numentities;i++)
2090                 {
2091                         ent = r_refdef.entities[i];
2092                         r_viewcache.entityvisible[i] = !(ent->flags & renderimask) && !R_CullBox(ent->mins, ent->maxs) && ((ent->effects & EF_NODEPTHTEST) || (ent->flags & RENDER_VIEWMODEL) || r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.worldmodel, r_viewcache.world_leafvisible, ent->mins, ent->maxs));
2093                 }
2094                 if(r_cullentities_trace.integer)
2095                 {
2096                         for (i = 0;i < r_refdef.numentities;i++)
2097                         {
2098                                 ent = r_refdef.entities[i];
2099                                 if(r_viewcache.entityvisible[i] && !(ent->effects & EF_NODEPTHTEST) && !(ent->flags & RENDER_VIEWMODEL) && !(ent->model && (ent->model->name[0] == '*')))
2100                                 {
2101                                         if(Mod_CanSeeBox_Trace(r_cullentities_trace_samples.integer, r_cullentities_trace_enlarge.value, r_refdef.worldmodel, r_view.origin, ent->mins, ent->maxs))
2102                                                 ent->last_trace_visibility = realtime;
2103                                         if(ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value)
2104                                                 r_viewcache.entityvisible[i] = 0;
2105                                 }
2106                         }
2107                 }
2108         }
2109         else
2110         {
2111                 // no worldmodel or it can't check visibility
2112                 for (i = 0;i < r_refdef.numentities;i++)
2113                 {
2114                         ent = r_refdef.entities[i];
2115                         r_viewcache.entityvisible[i] = !(ent->flags & renderimask) && !R_CullBox(ent->mins, ent->maxs);
2116                 }
2117         }
2118
2119         // update entity lighting (even on hidden entities for r_shadows)
2120         for (i = 0;i < r_refdef.numentities;i++)
2121                 R_UpdateEntityLighting(r_refdef.entities[i]);
2122 }
2123
2124 // only used if skyrendermasked, and normally returns false
2125 int R_DrawBrushModelsSky (void)
2126 {
2127         int i, sky;
2128         entity_render_t *ent;
2129
2130         if (!r_drawentities.integer)
2131                 return false;
2132
2133         sky = false;
2134         for (i = 0;i < r_refdef.numentities;i++)
2135         {
2136                 if (!r_viewcache.entityvisible[i])
2137                         continue;
2138                 ent = r_refdef.entities[i];
2139                 if (!ent->model || !ent->model->DrawSky)
2140                         continue;
2141                 ent->model->DrawSky(ent);
2142                 sky = true;
2143         }
2144         return sky;
2145 }
2146
2147 static void R_DrawNoModel(entity_render_t *ent);
2148 static void R_DrawModels(void)
2149 {
2150         int i;
2151         entity_render_t *ent;
2152
2153         if (!r_drawentities.integer)
2154                 return;
2155
2156         for (i = 0;i < r_refdef.numentities;i++)
2157         {
2158                 if (!r_viewcache.entityvisible[i])
2159                         continue;
2160                 ent = r_refdef.entities[i];
2161                 r_refdef.stats.entities++;
2162                 if (ent->model && ent->model->Draw != NULL)
2163                         ent->model->Draw(ent);
2164                 else
2165                         R_DrawNoModel(ent);
2166         }
2167 }
2168
2169 static void R_DrawModelsDepth(void)
2170 {
2171         int i;
2172         entity_render_t *ent;
2173
2174         if (!r_drawentities.integer)
2175                 return;
2176
2177         for (i = 0;i < r_refdef.numentities;i++)
2178         {
2179                 if (!r_viewcache.entityvisible[i])
2180                         continue;
2181                 ent = r_refdef.entities[i];
2182                 r_refdef.stats.entities++;
2183                 if (ent->model && ent->model->DrawDepth != NULL)
2184                         ent->model->DrawDepth(ent);
2185         }
2186 }
2187
2188 static void R_DrawModelsDebug(void)
2189 {
2190         int i;
2191         entity_render_t *ent;
2192
2193         if (!r_drawentities.integer)
2194                 return;
2195
2196         for (i = 0;i < r_refdef.numentities;i++)
2197         {
2198                 if (!r_viewcache.entityvisible[i])
2199                         continue;
2200                 ent = r_refdef.entities[i];
2201                 r_refdef.stats.entities++;
2202                 if (ent->model && ent->model->DrawDebug != NULL)
2203                         ent->model->DrawDebug(ent);
2204         }
2205 }
2206
2207 static void R_DrawModelsAddWaterPlanes(void)
2208 {
2209         int i;
2210         entity_render_t *ent;
2211
2212         if (!r_drawentities.integer)
2213                 return;
2214
2215         for (i = 0;i < r_refdef.numentities;i++)
2216         {
2217                 if (!r_viewcache.entityvisible[i])
2218                         continue;
2219                 ent = r_refdef.entities[i];
2220                 r_refdef.stats.entities++;
2221                 if (ent->model && ent->model->DrawAddWaterPlanes != NULL)
2222                         ent->model->DrawAddWaterPlanes(ent);
2223         }
2224 }
2225
2226 static void R_View_SetFrustum(void)
2227 {
2228         int i;
2229         double slopex, slopey;
2230
2231         // break apart the view matrix into vectors for various purposes
2232         Matrix4x4_ToVectors(&r_view.matrix, r_view.forward, r_view.left, r_view.up, r_view.origin);
2233         VectorNegate(r_view.left, r_view.right);
2234
2235 #if 0
2236         r_view.frustum[0].normal[0] = 0 - 1.0 / r_view.frustum_x;
2237         r_view.frustum[0].normal[1] = 0 - 0;
2238         r_view.frustum[0].normal[2] = -1 - 0;
2239         r_view.frustum[1].normal[0] = 0 + 1.0 / r_view.frustum_x;
2240         r_view.frustum[1].normal[1] = 0 + 0;
2241         r_view.frustum[1].normal[2] = -1 + 0;
2242         r_view.frustum[2].normal[0] = 0 - 0;
2243         r_view.frustum[2].normal[1] = 0 - 1.0 / r_view.frustum_y;
2244         r_view.frustum[2].normal[2] = -1 - 0;
2245         r_view.frustum[3].normal[0] = 0 + 0;
2246         r_view.frustum[3].normal[1] = 0 + 1.0 / r_view.frustum_y;
2247         r_view.frustum[3].normal[2] = -1 + 0;
2248 #endif
2249
2250 #if 0
2251         zNear = r_refdef.nearclip;
2252         nudge = 1.0 - 1.0 / (1<<23);
2253         r_view.frustum[4].normal[0] = 0 - 0;
2254         r_view.frustum[4].normal[1] = 0 - 0;
2255         r_view.frustum[4].normal[2] = -1 - -nudge;
2256         r_view.frustum[4].dist = 0 - -2 * zNear * nudge;
2257         r_view.frustum[5].normal[0] = 0 + 0;
2258         r_view.frustum[5].normal[1] = 0 + 0;
2259         r_view.frustum[5].normal[2] = -1 + -nudge;
2260         r_view.frustum[5].dist = 0 + -2 * zNear * nudge;
2261 #endif
2262
2263
2264
2265 #if 0
2266         r_view.frustum[0].normal[0] = m[3] - m[0];
2267         r_view.frustum[0].normal[1] = m[7] - m[4];
2268         r_view.frustum[0].normal[2] = m[11] - m[8];
2269         r_view.frustum[0].dist = m[15] - m[12];
2270
2271         r_view.frustum[1].normal[0] = m[3] + m[0];
2272         r_view.frustum[1].normal[1] = m[7] + m[4];
2273         r_view.frustum[1].normal[2] = m[11] + m[8];
2274         r_view.frustum[1].dist = m[15] + m[12];
2275
2276         r_view.frustum[2].normal[0] = m[3] - m[1];
2277         r_view.frustum[2].normal[1] = m[7] - m[5];
2278         r_view.frustum[2].normal[2] = m[11] - m[9];
2279         r_view.frustum[2].dist = m[15] - m[13];
2280
2281         r_view.frustum[3].normal[0] = m[3] + m[1];
2282         r_view.frustum[3].normal[1] = m[7] + m[5];
2283         r_view.frustum[3].normal[2] = m[11] + m[9];
2284         r_view.frustum[3].dist = m[15] + m[13];
2285
2286         r_view.frustum[4].normal[0] = m[3] - m[2];
2287         r_view.frustum[4].normal[1] = m[7] - m[6];
2288         r_view.frustum[4].normal[2] = m[11] - m[10];
2289         r_view.frustum[4].dist = m[15] - m[14];
2290
2291         r_view.frustum[5].normal[0] = m[3] + m[2];
2292         r_view.frustum[5].normal[1] = m[7] + m[6];
2293         r_view.frustum[5].normal[2] = m[11] + m[10];
2294         r_view.frustum[5].dist = m[15] + m[14];
2295 #endif
2296
2297
2298
2299         if (r_view.useperspective)
2300         {
2301                 slopex = 1.0 / r_view.frustum_x;
2302                 slopey = 1.0 / r_view.frustum_y;
2303                 VectorMA(r_view.forward, -slopex, r_view.left, r_view.frustum[0].normal);
2304                 VectorMA(r_view.forward,  slopex, r_view.left, r_view.frustum[1].normal);
2305                 VectorMA(r_view.forward, -slopey, r_view.up  , r_view.frustum[2].normal);
2306                 VectorMA(r_view.forward,  slopey, r_view.up  , r_view.frustum[3].normal);
2307                 VectorCopy(r_view.forward, r_view.frustum[4].normal);
2308
2309                 // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
2310                 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[0]);
2311                 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward,  1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[1]);
2312                 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left,  1024 * slopey, r_view.up, r_view.frustumcorner[2]);
2313                 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward,  1024 * slopex, r_view.left,  1024 * slopey, r_view.up, r_view.frustumcorner[3]);
2314
2315                 r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal);
2316                 r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal);
2317                 r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal);
2318                 r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal);
2319                 r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
2320         }
2321         else
2322         {
2323                 VectorScale(r_view.left, -r_view.ortho_x, r_view.frustum[0].normal);
2324                 VectorScale(r_view.left,  r_view.ortho_x, r_view.frustum[1].normal);
2325                 VectorScale(r_view.up, -r_view.ortho_y, r_view.frustum[2].normal);
2326                 VectorScale(r_view.up,  r_view.ortho_y, r_view.frustum[3].normal);
2327                 VectorCopy(r_view.forward, r_view.frustum[4].normal);
2328                 r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal) + r_view.ortho_x;
2329                 r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal) + r_view.ortho_x;
2330                 r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal) + r_view.ortho_y;
2331                 r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal) + r_view.ortho_y;
2332                 r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
2333         }
2334         r_view.numfrustumplanes = 5;
2335
2336         if (r_view.useclipplane)
2337         {
2338                 r_view.numfrustumplanes = 6;
2339                 r_view.frustum[5] = r_view.clipplane;
2340         }
2341
2342         for (i = 0;i < r_view.numfrustumplanes;i++)
2343                 PlaneClassify(r_view.frustum + i);
2344
2345         // LordHavoc: note to all quake engine coders, Quake had a special case
2346         // for 90 degrees which assumed a square view (wrong), so I removed it,
2347         // Quake2 has it disabled as well.
2348
2349         // rotate R_VIEWFORWARD right by FOV_X/2 degrees
2350         //RotatePointAroundVector( r_view.frustum[0].normal, r_view.up, r_view.forward, -(90 - r_refdef.fov_x / 2));
2351         //r_view.frustum[0].dist = DotProduct (r_view.origin, frustum[0].normal);
2352         //PlaneClassify(&frustum[0]);
2353
2354         // rotate R_VIEWFORWARD left by FOV_X/2 degrees
2355         //RotatePointAroundVector( r_view.frustum[1].normal, r_view.up, r_view.forward, (90 - r_refdef.fov_x / 2));
2356         //r_view.frustum[1].dist = DotProduct (r_view.origin, frustum[1].normal);
2357         //PlaneClassify(&frustum[1]);
2358
2359         // rotate R_VIEWFORWARD up by FOV_X/2 degrees
2360         //RotatePointAroundVector( r_view.frustum[2].normal, r_view.left, r_view.forward, -(90 - r_refdef.fov_y / 2));
2361         //r_view.frustum[2].dist = DotProduct (r_view.origin, frustum[2].normal);
2362         //PlaneClassify(&frustum[2]);
2363
2364         // rotate R_VIEWFORWARD down by FOV_X/2 degrees
2365         //RotatePointAroundVector( r_view.frustum[3].normal, r_view.left, r_view.forward, (90 - r_refdef.fov_y / 2));
2366         //r_view.frustum[3].dist = DotProduct (r_view.origin, frustum[3].normal);
2367         //PlaneClassify(&frustum[3]);
2368
2369         // nearclip plane
2370         //VectorCopy(r_view.forward, r_view.frustum[4].normal);
2371         //r_view.frustum[4].dist = DotProduct (r_view.origin, frustum[4].normal) + r_nearclip.value;
2372         //PlaneClassify(&frustum[4]);
2373 }
2374
2375 void R_View_Update(void)
2376 {
2377         R_View_SetFrustum();
2378         R_View_WorldVisibility(r_view.useclipplane);
2379         R_View_UpdateEntityVisible();
2380 }
2381
2382 void R_SetupView(void)
2383 {
2384         if (!r_view.useperspective)
2385                 GL_SetupView_Mode_Ortho(-r_view.ortho_x, -r_view.ortho_y, r_view.ortho_x, r_view.ortho_y, -r_refdef.farclip, r_refdef.farclip);
2386         else if (r_refdef.rtworldshadows || r_refdef.rtdlightshadows)
2387                 GL_SetupView_Mode_PerspectiveInfiniteFarClip(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip);
2388         else
2389                 GL_SetupView_Mode_Perspective(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip, r_refdef.farclip);
2390
2391         GL_SetupView_Orientation_FromEntity(&r_view.matrix);
2392
2393         if (r_view.useclipplane)
2394         {
2395                 // LordHavoc: couldn't figure out how to make this approach the
2396                 vec_t dist = r_view.clipplane.dist - r_water_clippingplanebias.value;
2397                 vec_t viewdist = DotProduct(r_view.origin, r_view.clipplane.normal);
2398                 if (viewdist < r_view.clipplane.dist + r_water_clippingplanebias.value)
2399                         dist = r_view.clipplane.dist;
2400                 GL_SetupView_ApplyCustomNearClipPlane(r_view.clipplane.normal[0], r_view.clipplane.normal[1], r_view.clipplane.normal[2], dist);
2401         }
2402 }
2403
2404 void R_ResetViewRendering2D(void)
2405 {
2406         if (gl_support_fragment_shader)
2407         {
2408                 qglUseProgramObjectARB(0);CHECKGLERROR
2409         }
2410
2411         DrawQ_Finish();
2412
2413         // GL is weird because it's bottom to top, r_view.y is top to bottom
2414         qglViewport(r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
2415         GL_SetupView_Mode_Ortho(0, 0, 1, 1, -10, 100);
2416         GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
2417         GL_Color(1, 1, 1, 1);
2418         GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
2419         GL_BlendFunc(GL_ONE, GL_ZERO);
2420         GL_AlphaTest(false);
2421         GL_ScissorTest(false);
2422         GL_DepthMask(false);
2423         GL_DepthRange(0, 1);
2424         GL_DepthTest(false);
2425         R_Mesh_Matrix(&identitymatrix);
2426         R_Mesh_ResetTextureState();
2427         GL_PolygonOffset(0, 0);
2428         qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
2429         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
2430         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2431         qglStencilMask(~0);CHECKGLERROR
2432         qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
2433         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
2434         GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces
2435 }
2436
2437 void R_ResetViewRendering3D(void)
2438 {
2439         if (gl_support_fragment_shader)
2440         {
2441                 qglUseProgramObjectARB(0);CHECKGLERROR
2442         }
2443
2444         DrawQ_Finish();
2445
2446         // GL is weird because it's bottom to top, r_view.y is top to bottom
2447         qglViewport(r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
2448         R_SetupView();
2449         GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
2450         GL_Color(1, 1, 1, 1);
2451         GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
2452         GL_BlendFunc(GL_ONE, GL_ZERO);
2453         GL_AlphaTest(false);
2454         GL_ScissorTest(true);
2455         GL_DepthMask(true);
2456         GL_DepthRange(0, 1);
2457         GL_DepthTest(true);
2458         R_Mesh_Matrix(&identitymatrix);
2459         R_Mesh_ResetTextureState();
2460         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
2461         qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
2462         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
2463         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2464         qglStencilMask(~0);CHECKGLERROR
2465         qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
2466         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
2467         GL_CullFace(r_view.cullface_back);
2468 }
2469
2470 /*
2471         R_Bloom_SetupShader(
2472 "// bloom shader\n"
2473 "// written by Forest 'LordHavoc' Hale\n"
2474 "\n"
2475 "// common definitions between vertex shader and fragment shader:\n"
2476 "\n"
2477 "#ifdef __GLSL_CG_DATA_TYPES\n"
2478 "#define myhalf half\n"
2479 "#define myhvec2 hvec2\n"
2480 "#define myhvec3 hvec3\n"
2481 "#define myhvec4 hvec4\n"
2482 "#else\n"
2483 "#define myhalf float\n"
2484 "#define myhvec2 vec2\n"
2485 "#define myhvec3 vec3\n"
2486 "#define myhvec4 vec4\n"
2487 "#endif\n"
2488 "\n"
2489 "varying vec2 ScreenTexCoord;\n"
2490 "varying vec2 BloomTexCoord;\n"
2491 "\n"
2492 "\n"
2493 "\n"
2494 "\n"
2495 "// vertex shader specific:\n"
2496 "#ifdef VERTEX_SHADER\n"
2497 "\n"
2498 "void main(void)\n"
2499 "{\n"
2500 "       ScreenTexCoord = vec2(gl_MultiTexCoord0);\n"
2501 "       BloomTexCoord = vec2(gl_MultiTexCoord1);\n"
2502 "       // transform vertex to camera space, using ftransform to match non-VS\n"
2503 "       // rendering\n"
2504 "       gl_Position = ftransform();\n"
2505 "}\n"
2506 "\n"
2507 "#endif // VERTEX_SHADER\n"
2508 "\n"
2509 "\n"
2510 "\n"
2511 "\n"
2512 "// fragment shader specific:\n"
2513 "#ifdef FRAGMENT_SHADER\n"
2514 "\n"
2515 "void main(void)\n"
2516 "{\n"
2517 "       int x, y;
2518 "       myhvec3 color = myhvec3(texture2D(Texture_Screen, ScreenTexCoord));\n"
2519 "       for (x = -BLUR_X;x <= BLUR_X;x++)
2520 "       color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2521 "       color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2522 "       color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2523 "       color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2524
2525 "       gl_FragColor = vec4(color);\n"
2526 "}\n"
2527 "\n"
2528 "#endif // FRAGMENT_SHADER\n"
2529 */
2530
2531 void R_RenderScene(qboolean addwaterplanes);
2532
2533 static void R_Water_StartFrame(void)
2534 {
2535         int i;
2536         int waterwidth, waterheight, texturewidth, textureheight;
2537         r_waterstate_waterplane_t *p;
2538
2539         // set waterwidth and waterheight to the water resolution that will be
2540         // used (often less than the screen resolution for faster rendering)
2541         waterwidth = (int)bound(1, r_view.width * r_water_resolutionmultiplier.value, r_view.width);
2542         waterheight = (int)bound(1, r_view.height * r_water_resolutionmultiplier.value, r_view.height);
2543
2544         // calculate desired texture sizes
2545         // can't use water if the card does not support the texture size
2546         if (!r_water.integer || !r_glsl.integer || !gl_support_fragment_shader || waterwidth > gl_max_texture_size || waterheight > gl_max_texture_size)
2547                 texturewidth = textureheight = waterwidth = waterheight = 0;
2548         else if (gl_support_arb_texture_non_power_of_two)
2549         {
2550                 texturewidth = waterwidth;
2551                 textureheight = waterheight;
2552         }
2553         else
2554         {
2555                 for (texturewidth   = 1;texturewidth   < waterwidth ;texturewidth   *= 2);
2556                 for (textureheight  = 1;textureheight  < waterheight;textureheight  *= 2);
2557         }
2558
2559         // allocate textures as needed
2560         if (r_waterstate.waterwidth != waterwidth || r_waterstate.waterheight != waterheight || r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight)
2561         {
2562                 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
2563                 for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
2564                 {
2565                         if (p->texture_refraction)
2566                                 R_FreeTexture(p->texture_refraction);
2567                         p->texture_refraction = NULL;
2568                         if (p->texture_reflection)
2569                                 R_FreeTexture(p->texture_reflection);
2570                         p->texture_reflection = NULL;
2571                 }
2572                 memset(&r_waterstate, 0, sizeof(r_waterstate));
2573                 r_waterstate.waterwidth = waterwidth;
2574                 r_waterstate.waterheight = waterheight;
2575                 r_waterstate.texturewidth = texturewidth;
2576                 r_waterstate.textureheight = textureheight;
2577         }
2578
2579         if (r_waterstate.waterwidth)
2580         {
2581                 r_waterstate.enabled = true;
2582
2583                 // set up variables that will be used in shader setup
2584                 r_waterstate.screenscale[0] = 0.5f * (float)waterwidth / (float)texturewidth;
2585                 r_waterstate.screenscale[1] = 0.5f * (float)waterheight / (float)textureheight;
2586                 r_waterstate.screencenter[0] = 0.5f * (float)waterwidth / (float)texturewidth;
2587                 r_waterstate.screencenter[1] = 0.5f * (float)waterheight / (float)textureheight;
2588         }
2589
2590         r_waterstate.maxwaterplanes = MAX_WATERPLANES;
2591         r_waterstate.numwaterplanes = 0;
2592 }
2593
2594 static void R_Water_AddWaterPlane(msurface_t *surface)
2595 {
2596         int triangleindex, planeindex;
2597         const int *e;
2598         vec_t f;
2599         vec3_t vert[3];
2600         vec3_t normal;
2601         vec3_t center;
2602         r_waterstate_waterplane_t *p;
2603         // just use the first triangle with a valid normal for any decisions
2604         VectorClear(normal);
2605         VectorClear(center);
2606         for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
2607         {
2608                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
2609                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
2610                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
2611                 TriangleNormal(vert[0], vert[1], vert[2], normal);
2612                 if (VectorLength2(normal) >= 0.001)
2613                         break;
2614         }
2615         // now find the center of this surface
2616         for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles*3;triangleindex++, e++)
2617         {
2618                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
2619                 VectorAdd(center, vert[0], center);
2620         }
2621         f = 1.0 / surface->num_triangles*3;
2622         VectorScale(center, f, center);
2623
2624         // find a matching plane if there is one
2625         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2626                 if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
2627                         break;
2628         if (planeindex >= r_waterstate.maxwaterplanes)
2629                 return; // nothing we can do, out of planes
2630
2631         // if this triangle does not fit any known plane rendered this frame, add one
2632         if (planeindex >= r_waterstate.numwaterplanes)
2633         {
2634                 // store the new plane
2635                 r_waterstate.numwaterplanes++;
2636                 VectorCopy(normal, p->plane.normal);
2637                 VectorNormalize(p->plane.normal);
2638                 p->plane.dist = DotProduct(vert[0], p->plane.normal);
2639                 PlaneClassify(&p->plane);
2640                 // flip the plane if it does not face the viewer
2641                 if (PlaneDiff(r_view.origin, &p->plane) < 0)
2642                 {
2643                         VectorNegate(p->plane.normal, p->plane.normal);
2644                         p->plane.dist *= -1;
2645                         PlaneClassify(&p->plane);
2646                 }
2647                 // clear materialflags and pvs
2648                 p->materialflags = 0;
2649                 p->pvsvalid = false;
2650         }
2651         // merge this surface's materialflags into the waterplane
2652         p->materialflags |= surface->texture->currentframe->currentmaterialflags;
2653         // merge this surface's PVS into the waterplane
2654         if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) && r_refdef.worldmodel && r_refdef.worldmodel->brush.FatPVS)
2655         {
2656                 r_refdef.worldmodel->brush.FatPVS(r_refdef.worldmodel, r_view.origin, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
2657                 p->pvsvalid = true;
2658         }
2659 }
2660
2661 static void R_Water_ProcessPlanes(void)
2662 {
2663         r_view_t originalview;
2664         int planeindex;
2665         r_waterstate_waterplane_t *p;
2666
2667         originalview = r_view;
2668
2669         // make sure enough textures are allocated
2670         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2671         {
2672                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
2673                 {
2674                         if (!p->texture_refraction)
2675                                 p->texture_refraction = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_refraction", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_RGBA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
2676                         if (!p->texture_refraction)
2677                                 goto error;
2678                 }
2679
2680                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
2681                 {
2682                         if (!p->texture_reflection)
2683                                 p->texture_reflection = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_reflection", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_RGBA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
2684                         if (!p->texture_reflection)
2685                                 goto error;
2686                 }
2687         }
2688
2689         // render views
2690         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2691         {
2692                 r_view.showdebug = false;
2693                 r_view.width = r_waterstate.waterwidth;
2694                 r_view.height = r_waterstate.waterheight;
2695                 r_view.useclipplane = true;
2696                 r_waterstate.renderingscene = true;
2697
2698                 // render the normal view scene and copy into texture
2699                 // (except that a clipping plane should be used to hide everything on one side of the water, and the viewer's weapon model should be omitted)
2700                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
2701                 {
2702                         r_view.clipplane = p->plane;
2703                         VectorNegate(r_view.clipplane.normal, r_view.clipplane.normal);
2704                         r_view.clipplane.dist = -r_view.clipplane.dist;
2705                         PlaneClassify(&r_view.clipplane);
2706
2707                         R_RenderScene(false);
2708
2709                         // copy view into the screen texture
2710                         R_Mesh_TexBind(0, R_GetTexture(p->texture_refraction));
2711                         GL_ActiveTexture(0);
2712                         CHECKGLERROR
2713                         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
2714                 }
2715
2716                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
2717                 {
2718                         // render reflected scene and copy into texture
2719                         Matrix4x4_Reflect(&r_view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
2720                         r_view.clipplane = p->plane;
2721                         // reverse the cullface settings for this render
2722                         r_view.cullface_front = GL_FRONT;
2723                         r_view.cullface_back = GL_BACK;
2724                         if (r_refdef.worldmodel && r_refdef.worldmodel->brush.num_pvsclusterbytes)
2725                         {
2726                                 r_view.usecustompvs = true;
2727                                 if (p->pvsvalid)
2728                                         memcpy(r_viewcache.world_pvsbits, p->pvsbits, r_refdef.worldmodel->brush.num_pvsclusterbytes);
2729                                 else
2730                                         memset(r_viewcache.world_pvsbits, 0xFF, r_refdef.worldmodel->brush.num_pvsclusterbytes);
2731                         }
2732
2733                         R_ResetViewRendering3D();
2734                         R_ClearScreen();
2735
2736                         R_RenderScene(false);
2737
2738                         R_Mesh_TexBind(0, R_GetTexture(p->texture_reflection));
2739                         GL_ActiveTexture(0);
2740                         CHECKGLERROR
2741                         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
2742
2743                         R_ResetViewRendering3D();
2744                         R_ClearScreen();
2745                 }
2746
2747                 r_view = originalview;
2748                 r_waterstate.renderingscene = false;
2749         }
2750         return;
2751 error:
2752         r_view = originalview;
2753         r_waterstate.renderingscene = false;
2754         Cvar_SetValueQuick(&r_water, 0);
2755         Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed!  Turned off r_water.\n");
2756         return;
2757 }
2758
2759 void R_Bloom_StartFrame(void)
2760 {
2761         int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
2762
2763         // set bloomwidth and bloomheight to the bloom resolution that will be
2764         // used (often less than the screen resolution for faster rendering)
2765         r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, r_view.width);
2766         r_bloomstate.bloomheight = r_bloomstate.bloomwidth * r_view.height / r_view.width;
2767         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_view.height);
2768
2769         // calculate desired texture sizes
2770         if (gl_support_arb_texture_non_power_of_two)
2771         {
2772                 screentexturewidth = r_view.width;
2773                 screentextureheight = r_view.height;
2774                 bloomtexturewidth = r_bloomstate.bloomwidth;
2775                 bloomtextureheight = r_bloomstate.bloomheight;
2776         }
2777         else
2778         {
2779                 for (screentexturewidth  = 1;screentexturewidth  < vid.width               ;screentexturewidth  *= 2);
2780                 for (screentextureheight = 1;screentextureheight < vid.height              ;screentextureheight *= 2);
2781                 for (bloomtexturewidth   = 1;bloomtexturewidth   < r_bloomstate.bloomwidth ;bloomtexturewidth   *= 2);
2782                 for (bloomtextureheight  = 1;bloomtextureheight  < r_bloomstate.bloomheight;bloomtextureheight  *= 2);
2783         }
2784
2785         if (r_hdr.integer)
2786         {
2787                 screentexturewidth = screentextureheight = 0;
2788         }
2789         else if (r_bloom.integer)
2790         {
2791         }
2792         else
2793         {
2794                 screentexturewidth = screentextureheight = 0;
2795                 bloomtexturewidth = bloomtextureheight = 0;
2796         }
2797
2798         if ((!bloomtexturewidth && !bloomtextureheight) || r_bloom_resolution.integer < 4 || r_bloom_blur.value < 1 || r_bloom_blur.value >= 512 || screentexturewidth > gl_max_texture_size || screentextureheight > gl_max_texture_size || bloomtexturewidth > gl_max_texture_size || bloomtextureheight > gl_max_texture_size)
2799         {
2800                 // can't use bloom if the parameters are too weird
2801                 // can't use bloom if the card does not support the texture size
2802                 if (r_bloomstate.texture_screen)
2803                         R_FreeTexture(r_bloomstate.texture_screen);
2804                 if (r_bloomstate.texture_bloom)
2805                         R_FreeTexture(r_bloomstate.texture_bloom);
2806                 memset(&r_bloomstate, 0, sizeof(r_bloomstate));
2807                 return;
2808         }
2809
2810         r_bloomstate.enabled = true;
2811         r_bloomstate.hdr = r_hdr.integer != 0;
2812
2813         // allocate textures as needed
2814         if (r_bloomstate.screentexturewidth != screentexturewidth || r_bloomstate.screentextureheight != screentextureheight)
2815         {
2816                 if (r_bloomstate.texture_screen)
2817                         R_FreeTexture(r_bloomstate.texture_screen);
2818                 r_bloomstate.texture_screen = NULL;
2819                 r_bloomstate.screentexturewidth = screentexturewidth;
2820                 r_bloomstate.screentextureheight = screentextureheight;
2821                 if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight)
2822                         r_bloomstate.texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", r_bloomstate.screentexturewidth, r_bloomstate.screentextureheight, NULL, TEXTYPE_RGBA, TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
2823         }
2824         if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight)
2825         {
2826                 if (r_bloomstate.texture_bloom)
2827                         R_FreeTexture(r_bloomstate.texture_bloom);
2828                 r_bloomstate.texture_bloom = NULL;
2829                 r_bloomstate.bloomtexturewidth = bloomtexturewidth;
2830                 r_bloomstate.bloomtextureheight = bloomtextureheight;
2831                 if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight)
2832                         r_bloomstate.texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", r_bloomstate.bloomtexturewidth, r_bloomstate.bloomtextureheight, NULL, TEXTYPE_RGBA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
2833         }
2834
2835         // set up a texcoord array for the full resolution screen image
2836         // (we have to keep this around to copy back during final render)
2837         r_bloomstate.screentexcoord2f[0] = 0;
2838         r_bloomstate.screentexcoord2f[1] = (float)r_view.height / (float)r_bloomstate.screentextureheight;
2839         r_bloomstate.screentexcoord2f[2] = (float)r_view.width / (float)r_bloomstate.screentexturewidth;
2840         r_bloomstate.screentexcoord2f[3] = (float)r_view.height / (float)r_bloomstate.screentextureheight;
2841         r_bloomstate.screentexcoord2f[4] = (float)r_view.width / (float)r_bloomstate.screentexturewidth;
2842         r_bloomstate.screentexcoord2f[5] = 0;
2843         r_bloomstate.screentexcoord2f[6] = 0;
2844         r_bloomstate.screentexcoord2f[7] = 0;
2845
2846         // set up a texcoord array for the reduced resolution bloom image
2847         // (which will be additive blended over the screen image)
2848         r_bloomstate.bloomtexcoord2f[0] = 0;
2849         r_bloomstate.bloomtexcoord2f[1] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
2850         r_bloomstate.bloomtexcoord2f[2] = (float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
2851         r_bloomstate.bloomtexcoord2f[3] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
2852         r_bloomstate.bloomtexcoord2f[4] = (float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
2853         r_bloomstate.bloomtexcoord2f[5] = 0;
2854         r_bloomstate.bloomtexcoord2f[6] = 0;
2855         r_bloomstate.bloomtexcoord2f[7] = 0;
2856 }
2857
2858 void R_Bloom_CopyScreenTexture(float colorscale)
2859 {
2860         r_refdef.stats.bloom++;
2861
2862         R_ResetViewRendering2D();
2863         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
2864         R_Mesh_ColorPointer(NULL, 0, 0);
2865         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
2866         R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen));
2867
2868         // copy view into the screen texture
2869         GL_ActiveTexture(0);
2870         CHECKGLERROR
2871         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
2872         r_refdef.stats.bloom_copypixels += r_view.width * r_view.height;
2873
2874         // now scale it down to the bloom texture size
2875         CHECKGLERROR
2876         qglViewport(r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
2877         GL_BlendFunc(GL_ONE, GL_ZERO);
2878         GL_Color(colorscale, colorscale, colorscale, 1);
2879         // TODO: optimize with multitexture or GLSL
2880         R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
2881         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2882
2883         // we now have a bloom image in the framebuffer
2884         // copy it into the bloom image texture for later processing
2885         R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
2886         GL_ActiveTexture(0);
2887         CHECKGLERROR
2888         qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
2889         r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2890 }
2891
2892 void R_Bloom_CopyHDRTexture(void)
2893 {
2894         R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
2895         GL_ActiveTexture(0);
2896         CHECKGLERROR
2897         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
2898         r_refdef.stats.bloom_copypixels += r_view.width * r_view.height;
2899 }
2900
2901 void R_Bloom_MakeTexture(void)
2902 {
2903         int x, range, dir;
2904         float xoffset, yoffset, r, brighten;
2905
2906         r_refdef.stats.bloom++;
2907
2908         R_ResetViewRendering2D();
2909         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
2910         R_Mesh_ColorPointer(NULL, 0, 0);
2911
2912         // we have a bloom image in the framebuffer
2913         CHECKGLERROR
2914         qglViewport(r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
2915
2916         for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
2917         {
2918                 x *= 2;
2919                 r = bound(0, r_bloom_colorexponent.value / x, 1);
2920                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
2921                 GL_Color(r, r, r, 1);
2922                 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
2923                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
2924                 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
2925                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2926
2927                 // copy the vertically blurred bloom view to a texture
2928                 GL_ActiveTexture(0);
2929                 CHECKGLERROR
2930                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
2931                 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2932         }
2933
2934         range = r_bloom_blur.integer * r_bloomstate.bloomwidth / 320;
2935         brighten = r_bloom_brighten.value;
2936         if (r_hdr.integer)
2937                 brighten *= r_hdr_range.value;
2938         R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
2939         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.offsettexcoord2f, 0, 0);
2940
2941         for (dir = 0;dir < 2;dir++)
2942         {
2943                 // blend on at multiple vertical offsets to achieve a vertical blur
2944                 // TODO: do offset blends using GLSL
2945                 GL_BlendFunc(GL_ONE, GL_ZERO);
2946                 for (x = -range;x <= range;x++)
2947                 {
2948                         if (!dir){xoffset = 0;yoffset = x;}
2949                         else {xoffset = x;yoffset = 0;}
2950                         xoffset /= (float)r_bloomstate.bloomtexturewidth;
2951                         yoffset /= (float)r_bloomstate.bloomtextureheight;
2952                         // compute a texcoord array with the specified x and y offset
2953                         r_bloomstate.offsettexcoord2f[0] = xoffset+0;
2954                         r_bloomstate.offsettexcoord2f[1] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
2955                         r_bloomstate.offsettexcoord2f[2] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
2956                         r_bloomstate.offsettexcoord2f[3] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
2957                         r_bloomstate.offsettexcoord2f[4] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
2958                         r_bloomstate.offsettexcoord2f[5] = yoffset+0;
2959                         r_bloomstate.offsettexcoord2f[6] = xoffset+0;
2960                         r_bloomstate.offsettexcoord2f[7] = yoffset+0;
2961                         // this r value looks like a 'dot' particle, fading sharply to
2962                         // black at the edges
2963                         // (probably not realistic but looks good enough)
2964                         //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
2965                         //r = (dir ? 1.0f : brighten)/(range*2+1);
2966                         r = (dir ? 1.0f : brighten)/(range*2+1)*(1 - x*x/(float)(range*range));
2967                         GL_Color(r, r, r, 1);
2968                         R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
2969                         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2970                         GL_BlendFunc(GL_ONE, GL_ONE);
2971                 }
2972
2973                 // copy the vertically blurred bloom view to a texture
2974                 GL_ActiveTexture(0);
2975                 CHECKGLERROR
2976                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
2977                 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2978         }
2979
2980         // apply subtract last
2981         // (just like it would be in a GLSL shader)
2982         if (r_bloom_colorsubtract.value > 0 && gl_support_ext_blend_subtract)
2983         {
2984                 GL_BlendFunc(GL_ONE, GL_ZERO);
2985                 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
2986                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
2987                 GL_Color(1, 1, 1, 1);
2988                 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
2989                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2990
2991                 GL_BlendFunc(GL_ONE, GL_ONE);
2992                 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
2993                 R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
2994                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
2995                 GL_Color(r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 1);
2996                 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
2997                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2998                 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
2999
3000                 // copy the darkened bloom view to a texture
3001                 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3002                 GL_ActiveTexture(0);
3003                 CHECKGLERROR
3004                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
3005                 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3006         }
3007 }
3008
3009 void R_HDR_RenderBloomTexture(void)
3010 {
3011         int oldwidth, oldheight;
3012
3013         oldwidth = r_view.width;
3014         oldheight = r_view.height;
3015         r_view.width = r_bloomstate.bloomwidth;
3016         r_view.height = r_bloomstate.bloomheight;
3017
3018         // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer?  it might improve SLI performance.
3019         // TODO: add exposure compensation features
3020         // TODO: add fp16 framebuffer support
3021
3022         r_view.showdebug = false;
3023         r_view.colorscale = r_bloom_colorscale.value * r_hdr_scenebrightness.value;
3024         if (r_hdr.integer)
3025                 r_view.colorscale /= r_hdr_range.value;
3026         r_waterstate.numwaterplanes = 0;
3027         R_RenderScene(r_waterstate.enabled);
3028         r_view.showdebug = true;
3029
3030         R_ResetViewRendering2D();
3031
3032         R_Bloom_CopyHDRTexture();
3033         R_Bloom_MakeTexture();
3034
3035         R_ResetViewRendering3D();
3036
3037         R_ClearScreen();
3038         if (r_timereport_active)
3039                 R_TimeReport("clear");
3040
3041
3042         // restore the view settings
3043         r_view.width = oldwidth;
3044         r_view.height = oldheight;
3045 }
3046
3047 static void R_BlendView(void)
3048 {
3049         if (r_bloomstate.enabled && r_bloomstate.hdr)
3050         {
3051                 // render high dynamic range bloom effect
3052                 // the bloom texture was made earlier this render, so we just need to
3053                 // blend it onto the screen...
3054                 R_ResetViewRendering2D();
3055                 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3056                 R_Mesh_ColorPointer(NULL, 0, 0);
3057                 GL_Color(1, 1, 1, 1);
3058                 GL_BlendFunc(GL_ONE, GL_ONE);
3059                 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3060                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3061                 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3062                 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
3063         }
3064         else if (r_bloomstate.enabled)
3065         {
3066                 // render simple bloom effect
3067                 // copy the screen and shrink it and darken it for the bloom process
3068                 R_Bloom_CopyScreenTexture(r_bloom_colorscale.value);
3069                 // make the bloom texture
3070                 R_Bloom_MakeTexture();
3071                 // put the original screen image back in place and blend the bloom
3072                 // texture on it
3073                 R_ResetViewRendering2D();
3074                 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3075                 R_Mesh_ColorPointer(NULL, 0, 0);
3076                 GL_Color(1, 1, 1, 1);
3077                 GL_BlendFunc(GL_ONE, GL_ZERO);
3078                 // do both in one pass if possible
3079                 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3080                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3081                 if (r_textureunits.integer >= 2 && gl_combine.integer)
3082                 {
3083                         R_Mesh_TexCombine(1, GL_ADD, GL_ADD, 1, 1);
3084                         R_Mesh_TexBind(1, R_GetTexture(r_bloomstate.texture_screen));
3085                         R_Mesh_TexCoordPointer(1, 2, r_bloomstate.screentexcoord2f, 0, 0);
3086                 }
3087                 else
3088                 {
3089                         R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3090                         r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
3091                         // now blend on the bloom texture
3092                         GL_BlendFunc(GL_ONE, GL_ONE);
3093                         R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen));
3094                         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
3095                 }
3096                 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3097                 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
3098         }
3099         if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
3100         {
3101                 // apply a color tint to the whole view
3102                 R_ResetViewRendering2D();
3103                 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3104                 R_Mesh_ColorPointer(NULL, 0, 0);
3105                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3106                 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
3107                 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3108         }
3109 }
3110
3111 void R_RenderScene(qboolean addwaterplanes);
3112
3113 matrix4x4_t r_waterscrollmatrix;
3114
3115 void R_UpdateVariables(void)
3116 {
3117         R_Textures_Frame();
3118
3119         r_refdef.farclip = 4096;
3120         if (r_refdef.worldmodel)
3121                 r_refdef.farclip += VectorDistance(r_refdef.worldmodel->normalmins, r_refdef.worldmodel->normalmaxs);
3122         r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
3123
3124         if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
3125                 Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
3126         r_refdef.polygonfactor = 0;
3127         r_refdef.polygonoffset = 0;
3128         r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
3129         r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
3130
3131         r_refdef.rtworld = r_shadow_realtime_world.integer;
3132         r_refdef.rtworldshadows = r_shadow_realtime_world_shadows.integer && gl_stencil;
3133         r_refdef.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer;
3134         r_refdef.rtdlightshadows = r_refdef.rtdlight && r_shadow_realtime_dlight_shadows.integer && gl_stencil;
3135         r_refdef.lightmapintensity = r_refdef.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
3136         if (r_showsurfaces.integer)
3137         {
3138                 r_refdef.rtworld = false;
3139                 r_refdef.rtworldshadows = false;
3140                 r_refdef.rtdlight = false;
3141                 r_refdef.rtdlightshadows = false;
3142                 r_refdef.lightmapintensity = 0;
3143         }
3144
3145         if (gamemode == GAME_NEHAHRA)
3146         {
3147                 if (gl_fogenable.integer)
3148                 {
3149                         r_refdef.oldgl_fogenable = true;
3150                         r_refdef.fog_density = gl_fogdensity.value;
3151                         r_refdef.fog_red = gl_fogred.value;
3152                         r_refdef.fog_green = gl_foggreen.value;
3153                         r_refdef.fog_blue = gl_fogblue.value;
3154                 }
3155                 else if (r_refdef.oldgl_fogenable)
3156                 {
3157                         r_refdef.oldgl_fogenable = false;
3158                         r_refdef.fog_density = 0;
3159                         r_refdef.fog_red = 0;
3160                         r_refdef.fog_green = 0;
3161                         r_refdef.fog_blue = 0;
3162                 }
3163         }
3164         if (r_refdef.fog_density)
3165         {
3166                 r_refdef.fogcolor[0] = bound(0.0f, r_refdef.fog_red  , 1.0f);
3167                 r_refdef.fogcolor[1] = bound(0.0f, r_refdef.fog_green, 1.0f);
3168                 r_refdef.fogcolor[2] = bound(0.0f, r_refdef.fog_blue , 1.0f);
3169         }
3170         if (r_refdef.fog_density)
3171         {
3172                 r_refdef.fogenabled = true;
3173                 // this is the point where the fog reaches 0.9986 alpha, which we
3174                 // consider a good enough cutoff point for the texture
3175                 // (0.9986 * 256 == 255.6)
3176                 r_refdef.fogrange = 400 / r_refdef.fog_density;
3177                 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
3178                 r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
3179                 // fog color was already set
3180         }
3181         else
3182                 r_refdef.fogenabled = false;
3183 }
3184
3185 /*
3186 ================
3187 R_RenderView
3188 ================
3189 */
3190 void R_RenderView(void)
3191 {
3192         if (!r_refdef.entities/* || !r_refdef.worldmodel*/)
3193                 return; //Host_Error ("R_RenderView: NULL worldmodel");
3194
3195         R_Shadow_UpdateWorldLightSelection();
3196
3197         R_Bloom_StartFrame();
3198         R_Water_StartFrame();
3199
3200         CHECKGLERROR
3201         if (r_timereport_active)
3202                 R_TimeReport("setup");
3203
3204         R_ResetViewRendering3D();
3205
3206         R_ClearScreen();
3207         if (r_timereport_active)
3208                 R_TimeReport(&q