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