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 vertices are dynamic (animated models), generate them into the temporary rsurface_array_model* arrays and point rsurface_model* at them instead of the static data from the model itself
2615         if (rsurface_generatedvertex)
2616         {
2617                 if (rsurface_texture->textureflags & (Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2))
2618                         generatetangents = true;
2619                 if (generatetangents)
2620                         generatenormals = true;
2621                 if (generatenormals && !rsurface_modelnormal3f)
2622                 {
2623                         rsurface_normal3f = rsurface_modelnormal3f = rsurface_array_modelnormal3f;
2624                         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);
2625                 }
2626                 if (generatetangents && !rsurface_modelsvector3f)
2627                 {
2628                         rsurface_svector3f = rsurface_modelsvector3f = rsurface_array_modelsvector3f;
2629                         rsurface_tvector3f = rsurface_modeltvector3f = rsurface_array_modeltvector3f;
2630                         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);
2631                 }
2632         }
2633         // if vertices are deformed (sprite flares and things in maps, possibly water waves, bulges and other deformations), generate them into rsurface_deform* arrays from whatever the rsurface_model* array pointers point to (may be static model data or generated data for an animated model)
2634         if (rsurface_texture->textureflags & (Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2))
2635         {
2636                 int texturesurfaceindex;
2637                 float center[3], forward[3], right[3], up[3], v[4][3];
2638                 matrix4x4_t matrix1, imatrix1;
2639                 Matrix4x4_Transform(&rsurface_entity->inversematrix, r_view.forward, forward);
2640                 Matrix4x4_Transform(&rsurface_entity->inversematrix, r_view.right, right);
2641                 Matrix4x4_Transform(&rsurface_entity->inversematrix, r_view.up, up);
2642                 // make deformed versions of only the model vertices used by the specified surfaces
2643                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2644                 {
2645                         int i, j;
2646                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2647                         // a single autosprite surface can contain multiple sprites...
2648                         for (j = 0;j < surface->num_vertices - 3;j += 4)
2649                         {
2650                                 VectorClear(center);
2651                                 for (i = 0;i < 4;i++)
2652                                         VectorAdd(center, (rsurface_modelvertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
2653                                 VectorScale(center, 0.25f, center);
2654                                 if (rsurface_texture->textureflags & Q3TEXTUREFLAG_AUTOSPRITE2)
2655                                 {
2656                                         forward[0] = rsurface_modelorg[0] - center[0];
2657                                         forward[1] = rsurface_modelorg[1] - center[1];
2658                                         forward[2] = 0;
2659                                         VectorNormalize(forward);
2660                                         right[0] = forward[1];
2661                                         right[1] = -forward[0];
2662                                         right[2] = 0;
2663                                         VectorSet(up, 0, 0, 1);
2664                                 }
2665                                 // FIXME: calculate vectors from triangle edges instead of using texture vectors as an easy way out?
2666                                 Matrix4x4_FromVectors(&matrix1, (rsurface_modelnormal3f + 3 * surface->num_firstvertex) + j*3, (rsurface_modelsvector3f + 3 * surface->num_firstvertex) + j*3, (rsurface_modeltvector3f + 3 * surface->num_firstvertex) + j*3, center);
2667                                 Matrix4x4_Invert_Simple(&imatrix1, &matrix1);
2668                                 for (i = 0;i < 4;i++)
2669                                         Matrix4x4_Transform(&imatrix1, (rsurface_modelvertex3f + 3 * surface->num_firstvertex) + (j+i)*3, v[i]);
2670                                 for (i = 0;i < 4;i++)
2671                                         VectorMAMAMAM(1, center, v[i][0], forward, v[i][1], right, v[i][2], up, rsurface_array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
2672                         }
2673                         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);
2674                         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);
2675                 }
2676                 rsurface_vertex3f = rsurface_array_deformedvertex3f;
2677                 rsurface_svector3f = rsurface_array_deformedsvector3f;
2678                 rsurface_tvector3f = rsurface_array_deformedtvector3f;
2679                 rsurface_normal3f = rsurface_array_deformednormal3f;
2680         }
2681         R_Mesh_VertexPointer(rsurface_vertex3f);
2682 }
2683
2684 void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacelist)
2685 {
2686         int texturesurfaceindex;
2687         const msurface_t *surface = texturesurfacelist[0];
2688         int firstvertex = surface->num_firstvertex;
2689         int endvertex = surface->num_firstvertex + surface->num_vertices;
2690         if (texturenumsurfaces == 1)
2691         {
2692                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2693                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
2694         }
2695         else if (r_batchmode.integer == 2)
2696         {
2697                 #define MAXBATCHTRIANGLES 4096
2698                 int batchtriangles = 0;
2699                 int batchelements[MAXBATCHTRIANGLES*3];
2700                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2701                 {
2702                         surface = texturesurfacelist[texturesurfaceindex];
2703                         if (surface->num_triangles >= 256 || (batchtriangles == 0 && texturesurfaceindex + 1 >= texturenumsurfaces))
2704                         {
2705                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
2706                                 continue;
2707                         }
2708                         if (batchtriangles + surface->num_triangles > MAXBATCHTRIANGLES)
2709                         {
2710                                 R_Mesh_Draw(firstvertex, endvertex - firstvertex, batchtriangles, batchelements);
2711                                 batchtriangles = 0;
2712                                 firstvertex = surface->num_firstvertex;
2713                                 endvertex = surface->num_firstvertex + surface->num_vertices;
2714                         }
2715                         else
2716                         {
2717                                 firstvertex = min(firstvertex, surface->num_firstvertex);
2718                                 endvertex = max(endvertex, surface->num_firstvertex + surface->num_vertices);
2719                         }
2720                         memcpy(batchelements + batchtriangles * 3, rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
2721                         batchtriangles += surface->num_triangles;
2722                 }
2723                 if (batchtriangles)
2724                         R_Mesh_Draw(firstvertex, endvertex - firstvertex, batchtriangles, batchelements);
2725         }
2726         else if (r_batchmode.integer == 1)
2727         {
2728                 int firsttriangle = 0;
2729                 int endtriangle = -1;
2730                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2731                 {
2732                         surface = texturesurfacelist[texturesurfaceindex];
2733                         if (surface->num_firsttriangle != endtriangle)
2734                         {
2735                                 if (endtriangle > firsttriangle)
2736                                 {
2737                                         GL_LockArrays(firstvertex, endvertex - firstvertex);
2738                                         R_Mesh_Draw(firstvertex, endvertex - firstvertex, endtriangle - firsttriangle, (rsurface_model->surfmesh.data_element3i + 3 * firsttriangle));
2739                                 }
2740                                 firstvertex = surface->num_firstvertex;
2741                                 endvertex = surface->num_firstvertex + surface->num_vertices;
2742                                 firsttriangle = surface->num_firsttriangle;
2743                         }
2744                         else
2745                         {
2746                                 firstvertex = min(firstvertex, surface->num_firstvertex);
2747                                 endvertex = max(endvertex, surface->num_firstvertex + surface->num_vertices);
2748                         }
2749                         endtriangle = surface->num_firsttriangle + surface->num_triangles;
2750                 }
2751                 if (endtriangle > firsttriangle)
2752                 {
2753                         GL_LockArrays(firstvertex, endvertex - firstvertex);
2754                         R_Mesh_Draw(firstvertex, endvertex - firstvertex, endtriangle - firsttriangle, (rsurface_model->surfmesh.data_element3i + 3 * firsttriangle));
2755                 }
2756         }
2757         else
2758         {
2759                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2760                 {
2761                         surface = texturesurfacelist[texturesurfaceindex];
2762                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2763                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
2764                 }
2765         }
2766 }
2767
2768 static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
2769 {
2770         int texturesurfaceindex;
2771         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2772         {
2773                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2774                 int k = (int)(((size_t)surface) / sizeof(msurface_t));
2775                 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);
2776                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2777                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
2778         }
2779 }
2780
2781 static void RSurf_DrawBatch_Lightmap(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, int lightmode, qboolean applycolor, qboolean applyfog)
2782 {
2783         int texturesurfaceindex;
2784         int i;
2785         float f;
2786         float *v, *c, *c2;
2787         // TODO: optimize
2788         if (lightmode >= 2)
2789         {
2790                 // model lighting
2791                 vec3_t ambientcolor;
2792                 vec3_t diffusecolor;
2793                 vec3_t lightdir;
2794                 VectorCopy(rsurface_entity->modellight_lightdir, lightdir);
2795                 ambientcolor[0] = rsurface_entity->modellight_ambient[0] * r * 0.5f;
2796                 ambientcolor[1] = rsurface_entity->modellight_ambient[1] * g * 0.5f;
2797                 ambientcolor[2] = rsurface_entity->modellight_ambient[2] * b * 0.5f;
2798                 diffusecolor[0] = rsurface_entity->modellight_diffuse[0] * r * 0.5f;
2799                 diffusecolor[1] = rsurface_entity->modellight_diffuse[1] * g * 0.5f;
2800                 diffusecolor[2] = rsurface_entity->modellight_diffuse[2] * b * 0.5f;
2801                 if (VectorLength2(diffusecolor) > 0)
2802                 {
2803                         // generate color arrays for the surfaces in this list
2804                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2805                         {
2806                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2807                                 int numverts = surface->num_vertices;
2808                                 v = rsurface_vertex3f + 3 * surface->num_firstvertex;
2809                                 c2 = rsurface_normal3f + 3 * surface->num_firstvertex;
2810                                 c = rsurface_array_color4f + 4 * surface->num_firstvertex;
2811                                 // q3-style directional shading
2812                                 for (i = 0;i < numverts;i++, v += 3, c2 += 3, c += 4)
2813                                 {
2814                                         if ((f = DotProduct(c2, lightdir)) > 0)
2815                                                 VectorMA(ambientcolor, f, diffusecolor, c);
2816                                         else
2817                                                 VectorCopy(ambientcolor, c);
2818                                         c[3] = a;
2819                                 }
2820                         }
2821                         r = 1;
2822                         g = 1;
2823                         b = 1;
2824                         a = 1;
2825                         applycolor = false;
2826                         rsurface_lightmapcolor4f = rsurface_array_color4f;
2827                 }
2828                 else
2829                 {
2830                         r = ambientcolor[0];
2831                         g = ambientcolor[1];
2832                         b = ambientcolor[2];
2833                         rsurface_lightmapcolor4f = NULL;
2834                 }
2835         }
2836         else if (lightmode >= 1 || !rsurface_lightmaptexture)
2837         {
2838                 if (texturesurfacelist[0]->lightmapinfo && texturesurfacelist[0]->lightmapinfo->stainsamples)
2839                 {
2840                         // generate color arrays for the surfaces in this list
2841                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2842                         {
2843                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2844                                 for (i = 0, c = rsurface_array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
2845                                 {
2846                                         if (surface->lightmapinfo->samples)
2847                                         {
2848                                                 const unsigned char *lm = surface->lightmapinfo->samples + (rsurface_model->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i];
2849                                                 float scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
2850                                                 VectorScale(lm, scale, c);
2851                                                 if (surface->lightmapinfo->styles[1] != 255)
2852                                                 {
2853                                                         int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
2854                                                         lm += size3;
2855                                                         scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
2856                                                         VectorMA(c, scale, lm, c);
2857                                                         if (surface->lightmapinfo->styles[2] != 255)
2858                                                         {
2859                                                                 lm += size3;
2860                                                                 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
2861                                                                 VectorMA(c, scale, lm, c);
2862                                                                 if (surface->lightmapinfo->styles[3] != 255)
2863                                                                 {
2864                                                                         lm += size3;
2865                                                                         scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
2866                                                                         VectorMA(c, scale, lm, c);
2867                                                                 }
2868                                                         }
2869                                                 }
2870                                         }
2871                                         else
2872                                                 VectorClear(c);
2873                                         c[3] = 1;
2874                                 }
2875                         }
2876                         rsurface_lightmapcolor4f = rsurface_array_color4f;
2877                 }
2878                 else
2879                         rsurface_lightmapcolor4f = rsurface_model->surfmesh.data_lightmapcolor4f;
2880         }
2881         else
2882         {
2883                 // just lightmap it
2884                 rsurface_lightmapcolor4f = NULL;
2885         }
2886         if (applyfog)
2887         {
2888                 if (rsurface_lightmapcolor4f)
2889                 {
2890                         // generate color arrays for the surfaces in this list
2891                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2892                         {
2893                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2894                                 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)
2895                                 {
2896                                         f = 1 - VERTEXFOGTABLE(VectorDistance(v, rsurface_modelorg));
2897                                         c2[0] = c[0] * f;
2898                                         c2[1] = c[1] * f;
2899                                         c2[2] = c[2] * f;
2900                                         c2[3] = c[3];
2901                                 }
2902                         }
2903                 }
2904                 else
2905                 {
2906                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2907                         {
2908                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2909                                 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)
2910                                 {
2911                                         f = 1 - VERTEXFOGTABLE(VectorDistance(v, rsurface_modelorg));
2912                                         c2[0] = f;
2913                                         c2[1] = f;
2914                                         c2[2] = f;
2915                                         c2[3] = 1;
2916                                 }
2917                         }
2918                 }
2919                 rsurface_lightmapcolor4f = rsurface_array_color4f;
2920         }
2921         if (applycolor && rsurface_lightmapcolor4f)
2922         {
2923                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2924                 {
2925                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2926                         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)
2927                         {
2928                                 c2[0] = c[0] * r;
2929                                 c2[1] = c[1] * g;
2930                                 c2[2] = c[2] * b;
2931                                 c2[3] = c[3] * a;
2932                         }
2933                 }
2934                 rsurface_lightmapcolor4f = rsurface_array_color4f;
2935         }
2936         R_Mesh_ColorPointer(rsurface_lightmapcolor4f);
2937         GL_Color(r, g, b, a);
2938         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
2939 }
2940
2941 static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
2942 {
2943         if (rsurface_mode != RSURFMODE_SHOWSURFACES)
2944         {
2945                 rsurface_mode = RSURFMODE_SHOWSURFACES;
2946                 GL_DepthMask(true);
2947                 GL_BlendFunc(GL_ONE, GL_ZERO);
2948                 R_Mesh_ColorPointer(NULL);
2949                 R_Mesh_ResetTextureState();
2950         }
2951         RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
2952         RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
2953 }
2954
2955 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, msurface_t **texturesurfacelist)
2956 {
2957         // transparent sky would be ridiculous
2958         if ((rsurface_texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT))
2959                 return;
2960         if (rsurface_mode != RSURFMODE_SKY)
2961         {
2962                 if (rsurface_mode == RSURFMODE_GLSL)
2963                 {
2964                         qglUseProgramObjectARB(0);CHECKGLERROR
2965                 }
2966                 rsurface_mode = RSURFMODE_SKY;
2967         }
2968         if (skyrendernow)
2969         {
2970                 skyrendernow = false;
2971                 R_Sky();
2972                 // restore entity matrix
2973                 R_Mesh_Matrix(&rsurface_entity->matrix);
2974         }
2975         GL_DepthMask(true);
2976         // LordHavoc: HalfLife maps have freaky skypolys so don't use
2977         // skymasking on them, and Quake3 never did sky masking (unlike
2978         // software Quake and software Quake2), so disable the sky masking
2979         // in Quake3 maps as it causes problems with q3map2 sky tricks,
2980         // and skymasking also looks very bad when noclipping outside the
2981         // level, so don't use it then either.
2982         if (rsurface_model->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_viewcache.world_novis)
2983         {
2984                 GL_Color(r_refdef.fogcolor[0] * r_view.colorscale, r_refdef.fogcolor[1] * r_view.colorscale, r_refdef.fogcolor[2] * r_view.colorscale, 1);
2985                 R_Mesh_ColorPointer(NULL);
2986                 R_Mesh_ResetTextureState();
2987                 if (skyrendermasked)
2988                 {
2989                         // depth-only (masking)
2990                         GL_ColorMask(0,0,0,0);
2991                         // just to make sure that braindead drivers don't draw
2992                         // anything despite that colormask...
2993                         GL_BlendFunc(GL_ZERO, GL_ONE);
2994                 }
2995                 else
2996                 {
2997                         // fog sky
2998                         GL_BlendFunc(GL_ONE, GL_ZERO);
2999                 }
3000                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
3001                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
3002                 if (skyrendermasked)
3003                         GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
3004         }
3005 }
3006
3007 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, msurface_t **texturesurfacelist)
3008 {
3009         int lightmode;
3010         // FIXME: identify models using a better check than rsurface_model->brush.shadowmesh
3011         lightmode = ((rsurface_entity->effects & EF_FULLBRIGHT) || rsurface_model->brush.shadowmesh) ? 0 : 2;
3012         if (rsurface_mode != RSURFMODE_GLSL)
3013         {
3014                 rsurface_mode = RSURFMODE_GLSL;
3015                 rsurface_glsl_texture = NULL;
3016                 rsurface_glsl_uselightmap = false;
3017                 R_Mesh_ResetTextureState();
3018         }
3019         if (rsurface_glsl_texture != rsurface_texture || rsurface_glsl_uselightmap != (rsurface_lightmaptexture != NULL))
3020         {
3021                 rsurface_glsl_texture = rsurface_texture;
3022                 rsurface_glsl_uselightmap = rsurface_lightmaptexture != NULL;
3023                 GL_BlendFunc(rsurface_texture->currentlayers[0].blendfunc1, rsurface_texture->currentlayers[0].blendfunc2);
3024                 GL_DepthMask(!(rsurface_texture->currentmaterialflags & MATERIALFLAG_BLENDED));
3025                 GL_Color(rsurface_entity->colormod[0], rsurface_entity->colormod[1], rsurface_entity->colormod[2], rsurface_texture->currentalpha);
3026                 R_SetupSurfaceShader(vec3_origin, lightmode == 2);
3027                 //permutation_deluxemapping = permutation_lightmapping = R_SetupSurfaceShader(vec3_origin, lightmode == 2, false);
3028                 //if (r_glsl_deluxemapping.integer)
3029                 //      permutation_deluxemapping = R_SetupSurfaceShader(vec3_origin, lightmode == 2, true);
3030                 R_Mesh_TexCoordPointer(0, 2, rsurface_model->surfmesh.data_texcoordtexture2f);
3031                 R_Mesh_TexCoordPointer(4, 2, rsurface_model->surfmesh.data_texcoordlightmap2f);
3032                 GL_AlphaTest((rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
3033         }
3034         if (!r_glsl_permutation)
3035                 return;
3036         RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
3037         R_Mesh_TexCoordPointer(1, 3, rsurface_svector3f);
3038         R_Mesh_TexCoordPointer(2, 3, rsurface_tvector3f);
3039         R_Mesh_TexCoordPointer(3, 3, rsurface_normal3f);
3040         if (rsurface_texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
3041         {
3042                 R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
3043                 if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
3044                         R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
3045                 R_Mesh_ColorPointer(NULL);
3046         }
3047         else if (rsurface_lightmaptexture)
3048         {
3049                 R_Mesh_TexBind(7, R_GetTexture(rsurface_lightmaptexture));
3050                 if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
3051                         R_Mesh_TexBind(8, R_GetTexture(texturesurfacelist[0]->deluxemaptexture));
3052                 R_Mesh_ColorPointer(NULL);
3053         }
3054         else
3055         {
3056                 R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
3057                 if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
3058                         R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
3059                 R_Mesh_ColorPointer(rsurface_model->surfmesh.data_lightmapcolor4f);
3060         }
3061         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
3062 }
3063
3064 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **texturesurfacelist)
3065 {
3066         // OpenGL 1.3 path - anything not completely ancient
3067         int texturesurfaceindex;
3068         int lightmode;
3069         qboolean applycolor;
3070         qboolean applyfog;
3071         rmeshstate_t m;
3072         int layerindex;
3073         const texturelayer_t *layer;
3074         CHECKGLERROR
3075         // FIXME: identify models using a better check than rsurface_model->brush.shadowmesh
3076         lightmode = ((rsurface_entity->effects & EF_FULLBRIGHT) || rsurface_model->brush.shadowmesh) ? 0 : 2;
3077         if (rsurface_mode != RSURFMODE_MULTIPASS)
3078                 rsurface_mode = RSURFMODE_MULTIPASS;
3079         RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
3080         for (layerindex = 0, layer = rsurface_texture->currentlayers;layerindex < rsurface_texture->currentnumlayers;layerindex++, layer++)
3081         {
3082                 vec4_t layercolor;
3083                 int layertexrgbscale;
3084                 if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
3085                 {
3086                         if (layerindex == 0)
3087                                 GL_AlphaTest(true);
3088                         else
3089                         {
3090                                 GL_AlphaTest(false);
3091                                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
3092                         }
3093                 }
3094                 GL_DepthMask(layer->depthmask);
3095                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
3096                 if ((layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2) && (gl_combine.integer || layer->depthmask))
3097                 {
3098                         layertexrgbscale = 4;
3099                         VectorScale(layer->color, 0.25f, layercolor);
3100                 }
3101                 else if ((layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1) && (gl_combine.integer || layer->depthmask))
3102                 {
3103                         layertexrgbscale = 2;
3104                         VectorScale(layer->color, 0.5f, layercolor);
3105                 }
3106                 else
3107                 {
3108                         layertexrgbscale = 1;
3109                         VectorScale(layer->color, 1.0f, layercolor);
3110                 }
3111                 layercolor[3] = layer->color[3];
3112                 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
3113                 R_Mesh_ColorPointer(NULL);
3114                 applyfog = (layer->flags & TEXTURELAYERFLAG_FOGDARKEN) != 0;
3115                 switch (layer->type)
3116                 {
3117                 case TEXTURELAYERTYPE_LITTEXTURE:
3118                         memset(&m, 0, sizeof(m));
3119                         if (lightmode >= 1 || !rsurface_lightmaptexture)
3120                                 m.tex[0] = R_GetTexture(r_texture_white);
3121                         else
3122                                 m.tex[0] = R_GetTexture(rsurface_lightmaptexture);
3123                         m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordlightmap2f;
3124                         m.tex[1] = R_GetTexture(layer->texture);
3125                         m.texmatrix[1] = layer->texmatrix;
3126                         m.texrgbscale[1] = layertexrgbscale;
3127                         m.pointer_texcoord[1] = rsurface_model->surfmesh.data_texcoordtexture2f;
3128                         R_Mesh_TextureState(&m);
3129                         RSurf_DrawBatch_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], lightmode, applycolor, applyfog);
3130                         break;
3131                 case TEXTURELAYERTYPE_TEXTURE:
3132                         memset(&m, 0, sizeof(m));
3133                         m.tex[0] = R_GetTexture(layer->texture);
3134                         m.texmatrix[0] = layer->texmatrix;
3135                         m.texrgbscale[0] = layertexrgbscale;
3136                         m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
3137                         R_Mesh_TextureState(&m);
3138                         RSurf_DrawBatch_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], 0, applycolor, applyfog);
3139                         break;
3140                 case TEXTURELAYERTYPE_FOG:
3141                         memset(&m, 0, sizeof(m));
3142                         m.texrgbscale[0] = layertexrgbscale;
3143                         if (layer->texture)
3144                         {
3145                                 m.tex[0] = R_GetTexture(layer->texture);
3146                                 m.texmatrix[0] = layer->texmatrix;
3147                                 m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
3148                         }
3149                         R_Mesh_TextureState(&m);
3150                         // generate a color array for the fog pass
3151                         R_Mesh_ColorPointer(rsurface_array_color4f);
3152                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
3153                         {
3154                                 int i;
3155                                 float f, *v, *c;
3156                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
3157                                 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)
3158                                 {
3159                                         f = VERTEXFOGTABLE(VectorDistance(v, rsurface_modelorg));
3160                                         c[0] = layercolor[0];
3161                                         c[1] = layercolor[1];
3162                                         c[2] = layercolor[2];
3163                                         c[3] = f * layercolor[3];
3164                                 }
3165                         }
3166                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
3167                         break;
3168                 default:
3169                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
3170                 }
3171                 GL_LockArrays(0, 0);
3172         }
3173         CHECKGLERROR
3174         if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
3175         {
3176                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
3177                 GL_AlphaTest(false);
3178         }
3179 }
3180
3181 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **texturesurfacelist)
3182 {
3183         // OpenGL 1.1 - crusty old voodoo path
3184         int texturesurfaceindex;
3185         int lightmode;
3186         qboolean applyfog;
3187         rmeshstate_t m;
3188         int layerindex;
3189         const texturelayer_t *layer;
3190         CHECKGLERROR
3191         // FIXME: identify models using a better check than rsurface_model->brush.shadowmesh
3192         lightmode = ((rsurface_entity->effects & EF_FULLBRIGHT) || rsurface_model->brush.shadowmesh) ? 0 : 2;
3193         if (rsurface_mode != RSURFMODE_MULTIPASS)
3194                 rsurface_mode = RSURFMODE_MULTIPASS;
3195         RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
3196         for (layerindex = 0, layer = rsurface_texture->currentlayers;layerindex < rsurface_texture->currentnumlayers;layerindex++, layer++)
3197         {
3198                 if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
3199                 {
3200                         if (layerindex == 0)
3201                                 GL_AlphaTest(true);
3202                         else
3203                         {
3204                                 GL_AlphaTest(false);
3205                                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
3206                         }
3207                 }
3208                 GL_DepthMask(layer->depthmask);
3209                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
3210                 R_Mesh_ColorPointer(NULL);
3211                 applyfog = (layer->flags & TEXTURELAYERFLAG_FOGDARKEN) != 0;
3212                 switch (layer->type)
3213                 {
3214                 case TEXTURELAYERTYPE_LITTEXTURE:
3215                         if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
3216                         {
3217                                 // two-pass lit texture with 2x rgbscale
3218                                 // first the lightmap pass
3219                                 memset(&m, 0, sizeof(m));
3220                                 if (lightmode >= 1 || !rsurface_lightmaptexture)
3221                                         m.tex[0] = R_GetTexture(r_texture_white);
3222                                 else
3223                                         m.tex[0] = R_GetTexture(rsurface_lightmaptexture);
3224                                 m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordlightmap2f;
3225                                 R_Mesh_TextureState(&m);
3226                                 RSurf_DrawBatch_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, lightmode, false, false);
3227                                 GL_LockArrays(0, 0);
3228                                 // then apply the texture to it
3229                                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
3230                                 memset(&m, 0, sizeof(m));
3231                                 m.tex[0] = R_GetTexture(layer->texture);
3232                                 m.texmatrix[0] = layer->texmatrix;
3233                                 m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
3234                                 R_Mesh_TextureState(&m);
3235                                 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);
3236                         }
3237                         else
3238                         {
3239                                 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
3240                                 memset(&m, 0, sizeof(m));
3241                                 m.tex[0] = R_GetTexture(layer->texture);
3242                                 m.texmatrix[0] = layer->texmatrix;
3243                                 m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
3244                                 R_Mesh_TextureState(&m);
3245                                 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);
3246                         }
3247                         break;
3248                 case TEXTURELAYERTYPE_TEXTURE:
3249                         // singletexture unlit texture with transparency support
3250                         memset(&m, 0, sizeof(m));
3251                         m.tex[0] = R_GetTexture(layer->texture);
3252                         m.texmatrix[0] = layer->texmatrix;
3253                         m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
3254                         R_Mesh_TextureState(&m);
3255                         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);
3256                         break;
3257                 case TEXTURELAYERTYPE_FOG:
3258                         // singletexture fogging
3259                         R_Mesh_ColorPointer(rsurface_array_color4f);
3260                         if (layer->texture)
3261                         {
3262                                 memset(&m, 0, sizeof(m));
3263                                 m.tex[0] = R_GetTexture(layer->texture);
3264                                 m.texmatrix[0] = layer->texmatrix;
3265                                 m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
3266                                 R_Mesh_TextureState(&m);
3267                         }
3268                         else
3269                                 R_Mesh_ResetTextureState();
3270                         // generate a color array for the fog pass
3271                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
3272                         {
3273                                 int i;
3274                                 float f, *v, *c;
3275                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
3276                                 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)
3277                                 {
3278                                         f = VERTEXFOGTABLE(VectorDistance(v, rsurface_modelorg));
3279                                         c[0] = layer->color[0];
3280                                         c[1] = layer->color[1];
3281                                         c[2] = layer->color[2];
3282                                         c[3] = f * layer->color[3];
3283                                 }
3284                         }
3285                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
3286                         break;
3287                 default:
3288                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
3289                 }
3290                 GL_LockArrays(0, 0);
3291         }
3292         CHECKGLERROR
3293         if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
3294         {
3295                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
3296                 GL_AlphaTest(false);
3297         }
3298 }
3299
3300 static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **texturesurfacelist)
3301 {
3302         if (rsurface_texture->currentmaterialflags & MATERIALFLAG_NODRAW)
3303                 return;
3304         r_shadow_rtlight = NULL;
3305         r_refdef.stats.entities_surfaces += texturenumsurfaces;
3306         CHECKGLERROR
3307         GL_DepthTest(!(rsurface_texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
3308         if ((rsurface_texture->textureflags & Q3TEXTUREFLAG_TWOSIDED) || (rsurface_entity->flags & RENDER_NOCULLFACE))
3309         {
3310                 qglDisable(GL_CULL_FACE);CHECKGLERROR
3311         }
3312         if (r_showsurfaces.integer)
3313                 R_DrawTextureSurfaceList_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
3314         else if (rsurface_texture->currentmaterialflags & MATERIALFLAG_SKY)
3315                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
3316         else if (rsurface_texture->currentnumlayers)
3317         {
3318                 if (r_glsl.integer && gl_support_fragment_shader)
3319                         R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist);
3320                 else if (gl_combine.integer && r_textureunits.integer >= 2)
3321                         R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist);
3322                 else
3323                         R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist);
3324         }
3325         CHECKGLERROR
3326         GL_LockArrays(0, 0);
3327         if ((rsurface_texture->textureflags & Q3TEXTUREFLAG_TWOSIDED) || (rsurface_entity->flags & RENDER_NOCULLFACE))
3328         {
3329                 qglEnable(GL_CULL_FACE);CHECKGLERROR
3330         }
3331 }
3332
3333 #define BATCHSIZE 256
3334 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
3335 {
3336         int surfacelistindex;
3337         int batchcount;
3338         texture_t *t;
3339         msurface_t *texturesurfacelist[BATCHSIZE];
3340         // if the model is static it doesn't matter what value we give for
3341         // wantnormals and wanttangents, so this logic uses only rules applicable
3342         // to a model, knowing that they are meaningless otherwise
3343         if ((ent->effects & EF_FULLBRIGHT) || r_showsurfaces.integer || VectorLength2(ent->modellight_diffuse) < (1.0f / 256.0f))
3344                 RSurf_ActiveEntity(ent, false, false);
3345         else
3346                 RSurf_ActiveEntity(ent, true, r_glsl.integer && gl_support_fragment_shader);
3347         batchcount = 0;
3348         t = NULL;
3349         for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
3350         {
3351                 msurface_t *surface = ent->model->data_surfaces + surfacelist[surfacelistindex];
3352
3353                 if (t != surface->texture || rsurface_lightmaptexture != surface->lightmaptexture)
3354                 {
3355                         if (batchcount > 0)
3356                                 R_DrawTextureSurfaceList(batchcount, texturesurfacelist);
3357                         batchcount = 0;
3358                         t = surface->texture;
3359                         rsurface_lightmaptexture = surface->lightmaptexture;
3360                         R_UpdateTextureInfo(ent, t);
3361                         rsurface_texture = t->currentframe;
3362                 }
3363                 if (rsurface_texture->currentmaterialflags & MATERIALFLAG_SKY)
3364                         continue; // transparent sky is too difficult
3365
3366                 texturesurfacelist[batchcount++] = surface;
3367         }
3368         if (batchcount > 0)
3369                 R_DrawTextureSurfaceList(batchcount, texturesurfacelist);
3370         RSurf_CleanUp();
3371 }
3372
3373 void R_QueueTextureSurfaceList(int texturenumsurfaces, msurface_t **texturesurfacelist)
3374 {
3375         int texturesurfaceindex;
3376         vec3_t tempcenter, center;
3377         if (rsurface_texture->currentmaterialflags & MATERIALFLAG_BLENDED)
3378         {
3379                 // drawing sky transparently would be too difficult
3380                 if (!(rsurface_texture->currentmaterialflags & MATERIALFLAG_SKY))
3381                 {
3382                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
3383                         {
3384                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
3385                                 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
3386                                 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
3387                                 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
3388                                 Matrix4x4_Transform(&rsurface_entity->matrix, tempcenter, center);
3389                                 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);
3390                         }
3391                 }
3392         }
3393         else
3394                 R_DrawTextureSurfaceList(texturenumsurfaces, texturesurfacelist);
3395 }
3396
3397 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
3398 void R_DrawSurfaces(entity_render_t *ent, qboolean skysurfaces)
3399 {
3400         int i, j, f, flagsmask;
3401         int counttriangles = 0;
3402         texture_t *t;
3403         model_t *model = ent->model;
3404         const int maxsurfacelist = 1024;
3405         int numsurfacelist = 0;
3406         msurface_t *surfacelist[1024];
3407         if (model == NULL)
3408                 return;
3409
3410         // if the model is static it doesn't matter what value we give for
3411         // wantnormals and wanttangents, so this logic uses only rules applicable
3412         // to a model, knowing that they are meaningless otherwise
3413         if ((ent->effects & EF_FULLBRIGHT) || r_showsurfaces.integer || VectorLength2(ent->modellight_diffuse) < (1.0f / 256.0f))
3414                 RSurf_ActiveEntity(ent, false, false);
3415         else
3416                 RSurf_ActiveEntity(ent, true, r_glsl.integer && gl_support_fragment_shader);
3417
3418         // update light styles
3419         if (!skysurfaces && model->brushq1.light_styleupdatechains)
3420         {
3421                 msurface_t *surface, **surfacechain;
3422                 for (i = 0;i < model->brushq1.light_styles;i++)
3423                 {
3424                         if (model->brushq1.light_stylevalue[i] != r_refdef.lightstylevalue[model->brushq1.light_style[i]])
3425                         {
3426                                 model->brushq1.light_stylevalue[i] = r_refdef.lightstylevalue[model->brushq1.light_style[i]];
3427                                 if ((surfacechain = model->brushq1.light_styleupdatechains[i]))
3428                                         for (;(surface = *surfacechain);surfacechain++)
3429                                                 surface->cached_dlight = true;
3430                         }
3431                 }
3432         }
3433
3434         R_UpdateAllTextureInfo(ent);
3435         flagsmask = skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL);
3436         f = 0;
3437         t = NULL;
3438         rsurface_lightmaptexture = NULL;
3439         rsurface_texture = NULL;
3440         numsurfacelist = 0;
3441         if (ent == r_refdef.worldentity)
3442         {
3443                 msurface_t *surface;
3444                 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
3445                 {
3446                         if (!r_viewcache.world_surfacevisible[j])
3447                                 continue;
3448                         if (t != surface->texture || rsurface_lightmaptexture != surface->lightmaptexture)
3449                         {
3450                                 if (numsurfacelist)
3451                                 {
3452                                         R_QueueTextureSurfaceList(numsurfacelist, surfacelist);
3453                                         numsurfacelist = 0;
3454                                 }
3455                                 t = surface->texture;
3456                                 rsurface_lightmaptexture = surface->lightmaptexture;
3457                                 rsurface_texture = t->currentframe;
3458                                 f = rsurface_texture->currentmaterialflags & flagsmask;
3459                         }
3460                         if (f && surface->num_triangles)
3461                         {
3462                                 // if lightmap parameters changed, rebuild lightmap texture
3463                                 if (surface->cached_dlight)
3464                                         R_BuildLightMap(ent, surface);
3465                                 // add face to draw list
3466                                 surfacelist[numsurfacelist++] = surface;
3467                                 counttriangles += surface->num_triangles;
3468                                 if (numsurfacelist >= maxsurfacelist)
3469                                 {
3470                                         R_QueueTextureSurfaceList(numsurfacelist, surfacelist);
3471                                         numsurfacelist = 0;
3472                                 }
3473                         }
3474                 }
3475         }
3476         else
3477         {
3478                 msurface_t *surface;
3479                 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
3480                 {
3481                         if (t != surface->texture || rsurface_lightmaptexture != surface->lightmaptexture)
3482                         {
3483                                 if (numsurfacelist)
3484                                 {
3485                                         R_QueueTextureSurfaceList(numsurfacelist, surfacelist);
3486                                         numsurfacelist = 0;
3487                                 }
3488                                 t = surface->texture;
3489                                 rsurface_lightmaptexture = surface->lightmaptexture;
3490                                 rsurface_texture = t->currentframe;
3491                                 f = rsurface_texture->currentmaterialflags & flagsmask;
3492                         }
3493                         if (f && surface->num_triangles)
3494                         {
3495                                 // if lightmap parameters changed, rebuild lightmap texture
3496                                 if (surface->cached_dlight)
3497                                         R_BuildLightMap(ent, surface);
3498                                 // add face to draw list
3499                                 surfacelist[numsurfacelist++] = surface;
3500                                 counttriangles += surface->num_triangles;
3501                                 if (numsurfacelist >= maxsurfacelist)
3502                                 {
3503                                         R_QueueTextureSurfaceList(numsurfacelist, surfacelist);
3504                                         numsurfacelist = 0;
3505                                 }
3506                         }
3507                 }
3508         }
3509         if (numsurfacelist)
3510                 R_QueueTextureSurfaceList(numsurfacelist, surfacelist);
3511         r_refdef.stats.entities_triangles += counttriangles;
3512         RSurf_CleanUp();
3513
3514         if (r_showcollisionbrushes.integer && model->brush.num_brushes && !skysurfaces)
3515         {
3516                 int i;
3517                 const msurface_t *surface;
3518                 q3mbrush_t *brush;
3519                 CHECKGLERROR
3520                 R_Mesh_Matrix(&ent->matrix);
3521                 R_Mesh_ColorPointer(NULL);
3522                 R_Mesh_ResetTextureState();
3523                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
3524                 GL_DepthMask(false);
3525                 GL_DepthTest(!r_showdisabledepthtest.integer);
3526                 qglPolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);CHECKGLERROR
3527                 for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
3528                         if (brush->colbrushf && brush->colbrushf->numtriangles)
3529                                 R_DrawCollisionBrush(brush->colbrushf);
3530                 for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
3531                         if (surface->num_collisiontriangles)
3532                                 R_DrawCollisionSurface(ent, surface);
3533                 qglPolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
3534         }
3535
3536         if (r_showtris.integer || r_shownormals.integer)
3537         {
3538                 int k, l;
3539                 msurface_t *surface;
3540                 const int *elements;
3541                 vec3_t v;
3542                 CHECKGLERROR
3543                 GL_DepthTest(true);
3544                 GL_DepthMask(true);
3545                 if (r_showdisabledepthtest.integer)
3546                 {
3547                         qglDepthFunc(GL_ALWAYS);CHECKGLERROR
3548                 }
3549                 GL_BlendFunc(GL_ONE, GL_ZERO);
3550                 R_Mesh_ColorPointer(NULL);
3551                 R_Mesh_ResetTextureState();
3552                 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
3553                 {
3554                         if (ent == r_refdef.worldentity && !r_viewcache.world_surfacevisible[j])
3555                                 continue;
3556                         rsurface_texture = surface->texture->currentframe;
3557                         if ((rsurface_texture->currentmaterialflags & flagsmask) && surface->num_triangles)
3558                         {
3559                                 RSurf_PrepareVerticesForBatch(true, true, 1, &surface);
3560                                 if (r_showtris.integer)
3561                                 {
3562                                         if (!rsurface_texture->currentlayers->depthmask)
3563                                                 GL_Color(r_showtris.value * r_view.colorscale, 0, 0, 1);
3564                                         else if (ent == r_refdef.worldentity)
3565                                                 GL_Color(r_showtris.value * r_view.colorscale, r_showtris.value * r_view.colorscale, r_showtris.value * r_view.colorscale, 1);
3566                                         else
3567                                                 GL_Color(0, r_showtris.value * r_view.colorscale, 0, 1);
3568                                         elements = (ent->model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);
3569                                         CHECKGLERROR
3570                                         qglBegin(GL_LINES);
3571                                         for (k = 0;k < surface->num_triangles;k++, elements += 3)
3572                                         {
3573                                                 qglArrayElement(elements[0]);qglArrayElement(elements[1]);
3574                                                 qglArrayElement(elements[1]);qglArrayElement(elements[2]);
3575                                                 qglArrayElement(elements[2]);qglArrayElement(elements[0]);
3576                                         }
3577                                         qglEnd();
3578                                         CHECKGLERROR
3579                                 }
3580                                 if (r_shownormals.integer)
3581                                 {
3582                                         GL_Color(r_shownormals.value * r_view.colorscale, 0, 0, 1);
3583                                         qglBegin(GL_LINES);
3584                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
3585                                         {
3586                                                 VectorCopy(rsurface_vertex3f + l * 3, v);
3587                                                 qglVertex3f(v[0], v[1], v[2]);
3588                                                 VectorMA(v, 8, rsurface_svector3f + l * 3, v);
3589                                                 qglVertex3f(v[0], v[1], v[2]);
3590                                         }
3591                                         qglEnd();
3592                                         CHECKGLERROR
3593                                         GL_Color(0, 0, r_shownormals.value * r_view.colorscale, 1);
3594                                         qglBegin(GL_LINES);
3595                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
3596                                         {
3597                                                 VectorCopy(rsurface_vertex3f + l * 3, v);
3598                                                 qglVertex3f(v[0], v[1], v[2]);
3599                                                 VectorMA(v, 8, rsurface_tvector3f + l * 3, v);
3600                                                 qglVertex3f(v[0], v[1], v[2]);
3601                                         }
3602                                         qglEnd();
3603                                         CHECKGLERROR
3604                                         GL_Color(0, r_shownormals.value * r_view.colorscale, 0, 1);
3605                                         qglBegin(GL_LINES);
3606                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
3607                                         {
3608                                                 VectorCopy(rsurface_vertex3f + l * 3, v);
3609                                                 qglVertex3f(v[0], v[1], v[2]);
3610                                                 VectorMA(v, 8, rsurface_normal3f + l * 3, v);
3611                                                 qglVertex3f(v[0], v[1], v[2]);
3612                                         }
3613                                         qglEnd();
3614                                         CHECKGLERROR
3615                                 }
3616                         }
3617                 }
3618                 rsurface_texture = NULL;
3619                 if (r_showdisabledepthtest.integer)
3620                 {
3621                         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
3622                 }
3623         }
3624 }
3625