gl_rmain.c

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