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->currentskinframe->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->currentskinframe->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->currentskinframe->pants));
 881         if (r_glsl_permutation->loc_Texture_Shirt >= 0) R_Mesh_TexBind(6, R_GetTexture(rsurface_texture->currentskinframe->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->currentskinframe->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->currentskinframe->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->currentskinframe->shirt)
 906                         qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface_entity->colormap_shirtcolor[0], rsurface_entity->colormap_shirtcolor[1], rsurface_entity->colormap_shirtcolor[2]);
 907                 else
 908                         qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
 909         }
 910         if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, r_refdef.fograngerecip);
 911         if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface_texture->specularpower);
 912         if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);
 913         CHECKGLERROR
 914         return permutation;
 915 }
 916
 917 void R_SwitchSurfaceShader(int permutation)
 918 {
 919         if (r_glsl_permutation != r_glsl_permutations + permutation)
 920         {
 921                 r_glsl_permutation = r_glsl_permutations + permutation;
 922                 CHECKGLERROR
 923                 qglUseProgramObjectARB(r_glsl_permutation->program);
 924                 CHECKGLERROR
 925         }
 926 }
 927
 928 void gl_main_start(void)
 929 {
 930         r_main_texturepool = R_AllocTexturePool();
 931         r_bloom_texture_screen = NULL;
 932         r_bloom_texture_bloom = NULL;
 933         R_BuildBlankTextures();
 934         R_BuildNoTexture();
 935         if (gl_texturecubemap)
 936         {
 937                 R_BuildWhiteCube();
 938                 R_BuildNormalizationCube();
 939         }
 940         R_BuildFogTexture();
 941         memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
 942 }
 943
 944 void gl_main_shutdown(void)
 945 {
 946         R_FreeTexturePool(&r_main_texturepool);
 947         r_bloom_texture_screen = NULL;
 948         r_bloom_texture_bloom = NULL;
 949         r_texture_blanknormalmap = NULL;
 950         r_texture_white = NULL;
 951         r_texture_black = NULL;
 952         r_texture_whitecube = NULL;
 953         r_texture_normalizationcube = NULL;
 954         R_GLSL_Restart_f();
 955 }
 956
 957 extern void CL_ParseEntityLump(char *entitystring);
 958 void gl_main_newmap(void)
 959 {
 960         // FIXME: move this code to client
 961         int l;
 962         char *entities, entname[MAX_QPATH];
 963         if (cl.worldmodel)
 964         {
 965                 strlcpy(entname, cl.worldmodel->name, sizeof(entname));
 966                 l = (int)strlen(entname) - 4;
 967                 if (l >= 0 && !strcmp(entname + l, ".bsp"))
 968                 {
 969                         memcpy(entname + l, ".ent", 5);
 970                         if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
 971                         {
 972                                 CL_ParseEntityLump(entities);
 973                                 Mem_Free(entities);
 974                                 return;
 975                         }
 976                 }
 977                 if (cl.worldmodel->brush.entities)
 978                         CL_ParseEntityLump(cl.worldmodel->brush.entities);
 979         }
 980 }
 981
 982 void GL_Main_Init(void)
 983 {
 984         r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
 985
 986         Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed\n");
 987         FOG_registercvars(); // FIXME: move this fog stuff to client?
 988         Cvar_RegisterVariable(&r_nearclip);
 989         Cvar_RegisterVariable(&r_showsurfaces);
 990         Cvar_RegisterVariable(&r_showtris);
 991         Cvar_RegisterVariable(&r_shownormals);
 992         Cvar_RegisterVariable(&r_showlighting);
 993         Cvar_RegisterVariable(&r_showshadowvolumes);
 994         Cvar_RegisterVariable(&r_showcollisionbrushes);
 995         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
 996         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
 997         Cvar_RegisterVariable(&r_showdisabledepthtest);
 998         Cvar_RegisterVariable(&r_drawportals);
 999         Cvar_RegisterVariable(&r_drawentities);
1000         Cvar_RegisterVariable(&r_drawviewmodel);
1001         Cvar_RegisterVariable(&r_speeds);
1002         Cvar_RegisterVariable(&r_fullbrights);
1003         Cvar_RegisterVariable(&r_wateralpha);
1004         Cvar_RegisterVariable(&r_dynamic);
1005         Cvar_RegisterVariable(&r_fullbright);
1006         Cvar_RegisterVariable(&r_q1bsp_skymasking);
1007         Cvar_RegisterVariable(&r_textureunits);
1008         Cvar_RegisterVariable(&r_glsl);
1009         Cvar_RegisterVariable(&r_glsl_offsetmapping);
1010         Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
1011         Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
1012         Cvar_RegisterVariable(&r_glsl_deluxemapping);
1013         Cvar_RegisterVariable(&r_lerpsprites);
1014         Cvar_RegisterVariable(&r_lerpmodels);
1015         Cvar_RegisterVariable(&r_waterscroll);
1016         Cvar_RegisterVariable(&r_bloom);
1017         Cvar_RegisterVariable(&r_bloom_intensity);
1018         Cvar_RegisterVariable(&r_bloom_blur);
1019         Cvar_RegisterVariable(&r_bloom_resolution);
1020         Cvar_RegisterVariable(&r_bloom_power);
1021         Cvar_RegisterVariable(&r_hdr);
1022         Cvar_RegisterVariable(&r_hdr_scenebrightness);
1023         Cvar_RegisterVariable(&r_hdr_bloomintensity);
1024         Cvar_RegisterVariable(&r_hdr_glowintensity);
1025         Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
1026         Cvar_RegisterVariable(&developer_texturelogging);
1027         Cvar_RegisterVariable(&gl_lightmaps);
1028         Cvar_RegisterVariable(&r_test);
1029         Cvar_RegisterVariable(&r_batchmode);
1030         if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
1031                 Cvar_SetValue("r_fullbrights", 0);
1032         R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap);
1033 }
1034
1035 extern void R_Textures_Init(void);
1036 extern void GL_Draw_Init(void);
1037 extern void GL_Main_Init(void);
1038 extern void R_Shadow_Init(void);
1039 extern void R_Sky_Init(void);
1040 extern void GL_Surf_Init(void);
1041 extern void R_Light_Init(void);
1042 extern void R_Particles_Init(void);
1043 extern void R_Explosion_Init(void);
1044 extern void gl_backend_init(void);
1045 extern void Sbar_Init(void);
1046 extern void R_LightningBeams_Init(void);
1047 extern void Mod_RenderInit(void);
1048
1049 void Render_Init(void)
1050 {
1051         gl_backend_init();
1052         R_Textures_Init();
1053         GL_Main_Init();
1054         GL_Draw_Init();
1055         R_Shadow_Init();
1056         R_Sky_Init();
1057         GL_Surf_Init();
1058         Sbar_Init();
1059         R_Light_Init();
1060         R_Particles_Init();
1061         R_Explosion_Init();
1062         R_LightningBeams_Init();
1063         Mod_RenderInit();
1064 }
1065
1066 /*
1067 ===============
1068 GL_Init
1069 ===============
1070 */
1071 extern char *ENGINE_EXTENSIONS;
1072 void GL_Init (void)
1073 {
1074         VID_CheckExtensions();
1075
1076         // LordHavoc: report supported extensions
1077         Con_DPrintf("\nengine extensions: %s\n", vm_sv_extensions );
1078
1079         // clear to black (loading plaque will be seen over this)
1080         CHECKGLERROR
1081         qglClearColor(0,0,0,1);CHECKGLERROR
1082         qglClear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
1083 }
1084
1085 int R_CullBox(const vec3_t mins, const vec3_t maxs)
1086 {
1087         int i;
1088         mplane_t *p;
1089         for (i = 0;i < 4;i++)
1090         {
1091                 p = r_view.frustum + i;
1092                 switch(p->signbits)
1093                 {
1094                 default:
1095                 case 0:
1096                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
1097                                 return true;
1098                         break;
1099                 case 1:
1100                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
1101                                 return true;
1102                         break;
1103                 case 2:
1104                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
1105                                 return true;
1106                         break;
1107                 case 3:
1108                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
1109                                 return true;
1110                         break;
1111                 case 4:
1112                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
1113                                 return true;
1114                         break;
1115                 case 5:
1116                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
1117                                 return true;
1118                         break;
1119                 case 6:
1120                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
1121                                 return true;
1122                         break;
1123                 case 7:
1124                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
1125                                 return true;
1126                         break;
1127                 }
1128         }
1129         return false;
1130 }
1131
1132 //==================================================================================
1133
1134 static void R_UpdateEntityLighting(entity_render_t *ent)
1135 {
1136         vec3_t tempdiffusenormal;
1137         VectorSet(ent->modellight_ambient, r_ambient.value * (2.0f / 128.0f), r_ambient.value * (2.0f / 128.0f), r_ambient.value * (2.0f / 128.0f));
1138         VectorClear(ent->modellight_diffuse);
1139         VectorClear(ent->modellight_lightdir);
1140         if ((ent->flags & RENDER_LIGHT) && r_refdef.worldmodel && r_refdef.worldmodel->brush.LightPoint)
1141         {
1142                 vec3_t org;
1143                 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
1144                 r_refdef.worldmodel->brush.LightPoint(r_refdef.worldmodel, org, ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal);
1145         }
1146         else // highly rare
1147                 VectorSet(ent->modellight_ambient, 1, 1, 1);
1148         Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, ent->modellight_lightdir);
1149         VectorNormalize(ent->modellight_lightdir);
1150         ent->modellight_ambient[0] *= ent->colormod[0] * r_refdef.lightmapintensity;
1151         ent->modellight_ambient[1] *= ent->colormod[1] * r_refdef.lightmapintensity;
1152         ent->modellight_ambient[2] *= ent->colormod[2] * r_refdef.lightmapintensity;
1153         ent->modellight_diffuse[0] *= ent->colormod[0] * r_refdef.lightmapintensity;
1154         ent->modellight_diffuse[1] *= ent->colormod[1] * r_refdef.lightmapintensity;
1155         ent->modellight_diffuse[2] *= ent->colormod[2] * r_refdef.lightmapintensity;
1156 }
1157
1158 static void R_View_UpdateEntityVisible (void)
1159 {
1160         int i, renderimask;
1161         entity_render_t *ent;
1162
1163         if (!r_drawentities.integer)
1164                 return;
1165
1166         renderimask = r_refdef.envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL) : (chase_active.integer ? 0 : RENDER_EXTERIORMODEL);
1167         if (r_refdef.worldmodel && r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs)
1168         {
1169                 // worldmodel can check visibility
1170                 for (i = 0;i < r_refdef.numentities;i++)
1171                 {
1172                         ent = r_refdef.entities[i];
1173                         r_viewcache.entityvisible[i] = !(ent->flags & renderimask) && !R_CullBox(ent->mins, ent->maxs) && ((ent->effects & EF_NODEPTHTEST) || r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.worldmodel, r_viewcache.world_leafvisible, ent->mins, ent->maxs));
1174                 }
1175         }
1176         else
1177         {
1178                 // no worldmodel or it can't check visibility
1179                 for (i = 0;i < r_refdef.numentities;i++)
1180                 {
1181                         ent = r_refdef.entities[i];
1182                         r_viewcache.entityvisible[i] = !(ent->flags & renderimask) && !R_CullBox(ent->mins, ent->maxs);
1183                 }
1184         }
1185 }
1186
1187 // only used if skyrendermasked, and normally returns false
1188 int R_DrawBrushModelsSky (void)
1189 {
1190         int i, sky;
1191         entity_render_t *ent;
1192
1193         if (!r_drawentities.integer)
1194                 return false;
1195
1196         sky = false;
1197         for (i = 0;i < r_refdef.numentities;i++)
1198         {
1199                 if (!r_viewcache.entityvisible[i])
1200                         continue;
1201                 ent = r_refdef.entities[i];
1202                 if (!ent->model || !ent->model->DrawSky)
1203                         continue;
1204                 ent->model->DrawSky(ent);
1205                 sky = true;
1206         }
1207         return sky;
1208 }
1209
1210 void R_DrawNoModel(entity_render_t *ent);
1211 void R_DrawModels(void)
1212 {
1213         int i;
1214         entity_render_t *ent;
1215
1216         if (!r_drawentities.integer)
1217                 return;
1218
1219         for (i = 0;i < r_refdef.numentities;i++)
1220         {
1221                 if (!r_viewcache.entityvisible[i])
1222                         continue;
1223                 ent = r_refdef.entities[i];
1224                 r_refdef.stats.entities++;
1225                 if (ent->model && ent->model->Draw != NULL)
1226                         ent->model->Draw(ent);
1227                 else
1228                         R_DrawNoModel(ent);
1229         }
1230 }
1231
1232 static void R_View_SetFrustum(void)
1233 {
1234         // break apart the view matrix into vectors for various purposes
1235         Matrix4x4_ToVectors(&r_view.matrix, r_view.forward, r_view.left, r_view.up, r_view.origin);
1236         VectorNegate(r_view.left, r_view.right);
1237
1238 #if 0
1239         r_view.frustum[0].normal[0] = 0 - 1.0 / r_view.frustum_x;
1240         r_view.frustum[0].normal[1] = 0 - 0;
1241         r_view.frustum[0].normal[2] = -1 - 0;
1242         r_view.frustum[1].normal[0] = 0 + 1.0 / r_view.frustum_x;
1243         r_view.frustum[1].normal[1] = 0 + 0;
1244         r_view.frustum[1].normal[2] = -1 + 0;
1245         r_view.frustum[2].normal[0] = 0 - 0;
1246         r_view.frustum[2].normal[1] = 0 - 1.0 / r_view.frustum_y;
1247         r_view.frustum[2].normal[2] = -1 - 0;
1248         r_view.frustum[3].normal[0] = 0 + 0;
1249         r_view.frustum[3].normal[1] = 0 + 1.0 / r_view.frustum_y;
1250         r_view.frustum[3].normal[2] = -1 + 0;
1251 #endif
1252
1253 #if 0
1254         zNear = r_refdef.nearclip;
1255         nudge = 1.0 - 1.0 / (1<<23);
1256         r_view.frustum[4].normal[0] = 0 - 0;
1257         r_view.frustum[4].normal[1] = 0 - 0;
1258         r_view.frustum[4].normal[2] = -1 - -nudge;
1259         r_view.frustum[4].dist = 0 - -2 * zNear * nudge;
1260         r_view.frustum[5].normal[0] = 0 + 0;
1261         r_view.frustum[5].normal[1] = 0 + 0;
1262         r_view.frustum[5].normal[2] = -1 + -nudge;
1263         r_view.frustum[5].dist = 0 + -2 * zNear * nudge;
1264 #endif
1265
1266
1267
1268 #if 0
1269         r_view.frustum[0].normal[0] = m[3] - m[0];
1270         r_view.frustum[0].normal[1] = m[7] - m[4];
1271         r_view.frustum[0].normal[2] = m[11] - m[8];
1272         r_view.frustum[0].dist = m[15] - m[12];
1273
1274         r_view.frustum[1].normal[0] = m[3] + m[0];
1275         r_view.frustum[1].normal[1] = m[7] + m[4];
1276         r_view.frustum[1].normal[2] = m[11] + m[8];
1277         r_view.frustum[1].dist = m[15] + m[12];
1278
1279         r_view.frustum[2].normal[0] = m[3] - m[1];
1280         r_view.frustum[2].normal[1] = m[7] - m[5];
1281         r_view.frustum[2].normal[2] = m[11] - m[9];
1282         r_view.frustum[2].dist = m[15] - m[13];
1283
1284         r_view.frustum[3].normal[0] = m[3] + m[1];
1285         r_view.frustum[3].normal[1] = m[7] + m[5];
1286         r_view.frustum[3].normal[2] = m[11] + m[9];
1287         r_view.frustum[3].dist = m[15] + m[13];
1288
1289         r_view.frustum[4].normal[0] = m[3] - m[2];
1290         r_view.frustum[4].normal[1] = m[7] - m[6];
1291         r_view.frustum[4].normal[2] = m[11] - m[10];
1292         r_view.frustum[4].dist = m[15] - m[14];
1293
1294         r_view.frustum[5].normal[0] = m[3] + m[2];
1295         r_view.frustum[5].normal[1] = m[7] + m[6];
1296         r_view.frustum[5].normal[2] = m[11] + m[10];
1297         r_view.frustum[5].dist = m[15] + m[14];
1298 #endif
1299
1300
1301
1302         VectorMAM(1, r_view.forward, 1.0 / -r_view.frustum_x, r_view.left, r_view.frustum[0].normal);
1303         VectorMAM(1, r_view.forward, 1.0 /  r_view.frustum_x, r_view.left, r_view.frustum[1].normal);
1304         VectorMAM(1, r_view.forward, 1.0 / -r_view.frustum_y, r_view.up, r_view.frustum[2].normal);
1305         VectorMAM(1, r_view.forward, 1.0 /  r_view.frustum_y, r_view.up, r_view.frustum[3].normal);
1306         VectorCopy(r_view.forward, r_view.frustum[4].normal);
1307         VectorNormalize(r_view.frustum[0].normal);
1308         VectorNormalize(r_view.frustum[1].normal);
1309         VectorNormalize(r_view.frustum[2].normal);
1310         VectorNormalize(r_view.frustum[3].normal);
1311         r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal);
1312         r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal);
1313         r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal);
1314         r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal);
1315         r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
1316         PlaneClassify(&r_view.frustum[0]);
1317         PlaneClassify(&r_view.frustum[1]);
1318         PlaneClassify(&r_view.frustum[2]);
1319         PlaneClassify(&r_view.frustum[3]);
1320         PlaneClassify(&r_view.frustum[4]);
1321
1322         // LordHavoc: note to all quake engine coders, Quake had a special case
1323         // for 90 degrees which assumed a square view (wrong), so I removed it,
1324         // Quake2 has it disabled as well.
1325
1326         // rotate R_VIEWFORWARD right by FOV_X/2 degrees
1327         //RotatePointAroundVector( r_view.frustum[0].normal, r_view.up, r_view.forward, -(90 - r_refdef.fov_x / 2));
1328         //r_view.frustum[0].dist = DotProduct (r_view.origin, frustum[0].normal);
1329         //PlaneClassify(&frustum[0]);
1330
1331         // rotate R_VIEWFORWARD left by FOV_X/2 degrees
1332         //RotatePointAroundVector( r_view.frustum[1].normal, r_view.up, r_view.forward, (90 - r_refdef.fov_x / 2));
1333         //r_view.frustum[1].dist = DotProduct (r_view.origin, frustum[1].normal);
1334         //PlaneClassify(&frustum[1]);
1335
1336         // rotate R_VIEWFORWARD up by FOV_X/2 degrees
1337         //RotatePointAroundVector( r_view.frustum[2].normal, r_view.left, r_view.forward, -(90 - r_refdef.fov_y / 2));
1338         //r_view.frustum[2].dist = DotProduct (r_view.origin, frustum[2].normal);
1339         //PlaneClassify(&frustum[2]);
1340
1341         // rotate R_VIEWFORWARD down by FOV_X/2 degrees
1342         //RotatePointAroundVector( r_view.frustum[3].normal, r_view.left, r_view.forward, (90 - r_refdef.fov_y / 2));
1343         //r_view.frustum[3].dist = DotProduct (r_view.origin, frustum[3].normal);
1344         //PlaneClassify(&frustum[3]);
1345
1346         // nearclip plane
1347         //VectorCopy(r_view.forward, r_view.frustum[4].normal);
1348         //r_view.frustum[4].dist = DotProduct (r_view.origin, frustum[4].normal) + r_nearclip.value;
1349         //PlaneClassify(&frustum[4]);
1350 }
1351
1352 void R_View_Update(void)
1353 {
1354         R_View_SetFrustum();
1355         R_View_WorldVisibility();
1356         R_View_UpdateEntityVisible();
1357 }
1358
1359 void R_ResetViewRendering(void)
1360 {
1361         if (gl_support_fragment_shader)
1362         {
1363                 qglUseProgramObjectARB(0);CHECKGLERROR
1364         }
1365
1366         // GL is weird because it's bottom to top, r_view.y is top to bottom
1367         qglViewport(r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
1368         GL_SetupView_Mode_Ortho(0, 0, 1, 1, -10, 100);
1369         GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
1370         GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
1371         GL_ScissorTest(true);
1372         GL_DepthMask(true);
1373         GL_DepthTest(true);
1374         R_Mesh_Matrix(&identitymatrix);
1375         R_Mesh_ResetTextureState();
1376 }
1377
1378 void R_RenderScene(void);
1379
1380 void R_Bloom_MakeTexture(qboolean darken)
1381 {
1382         int screenwidth, screenheight;
1383         int screentexturewidth, screentextureheight;
1384         int bloomtexturewidth, bloomtextureheight;
1385         int bloomwidth, bloomheight, x, range;
1386         float xoffset, yoffset, r;
1387         float vertex3f[12];
1388         float texcoord2f[3][8];
1389
1390         // set bloomwidth and bloomheight to the bloom resolution that will be
1391         // used (often less than the screen resolution for faster rendering)
1392         bloomwidth = bound(1, r_bloom_resolution.integer, r_view.width);
1393         bloomheight = bound(1, bloomwidth * r_view.height / r_view.width, r_view.height);
1394
1395         // set the (poorly named) screenwidth and screenheight variables to
1396         // a power of 2 at least as large as the screen, these will define the
1397         // size of the texture to allocate
1398         for (screenwidth = 1;screenwidth < vid.width;screenwidth *= 2);
1399         for (screenheight = 1;screenheight < vid.height;screenheight *= 2);
1400
1401         r_refdef.stats.bloom++;
1402
1403         // allocate textures as needed
1404         // TODO: reallocate these when size settings change
1405         if (!r_bloom_texture_screen)
1406                 r_bloom_texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", screenwidth, screenheight, NULL, TEXTYPE_RGBA, TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
1407         if (!r_bloom_texture_bloom)
1408                 r_bloom_texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", screenwidth, screenheight, NULL, TEXTYPE_RGBA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
1409
1410         screentexturewidth = R_TextureWidth(r_bloom_texture_screen);
1411         screentextureheight = R_TextureHeight(r_bloom_texture_screen);
1412         bloomtexturewidth = R_TextureWidth(r_bloom_texture_bloom);
1413         bloomtextureheight = R_TextureHeight(r_bloom_texture_bloom);
1414
1415         // vertex coordinates for a quad that covers the screen exactly
1416         vertex3f[0] = 0;vertex3f[1] = 0;vertex3f[2] = 0;
1417         vertex3f[3] = 1;vertex3f[4] = 0;vertex3f[5] = 0;
1418         vertex3f[6] = 1;vertex3f[7] = 1;vertex3f[8] = 0;
1419         vertex3f[9] = 0;vertex3f[10] = 1;vertex3f[11] = 0;
1420
1421         // set up a texcoord array for the full resolution screen image
1422         // (we have to keep this around to copy back during final render)
1423         texcoord2f[0][0] = 0;
1424         texcoord2f[0][1] = (float)r_view.height / (float)screentextureheight;
1425         texcoord2f[0][2] = (float)r_view.width / (float)screentexturewidth;
1426         texcoord2f[0][3] = (float)r_view.height / (float)screentextureheight;
1427         texcoord2f[0][4] = (float)r_view.width / (float)screentexturewidth;
1428         texcoord2f[0][5] = 0;
1429         texcoord2f[0][6] = 0;
1430         texcoord2f[0][7] = 0;
1431
1432         // set up a texcoord array for the reduced resolution bloom image
1433         // (which will be additive blended over the screen image)
1434         texcoord2f[1][0] = 0;
1435         texcoord2f[1][1] = (float)bloomheight / (float)bloomtextureheight;
1436         texcoord2f[1][2] = (float)bloomwidth / (float)bloomtexturewidth;
1437         texcoord2f[1][3] = (float)bloomheight / (float)bloomtextureheight;
1438         texcoord2f[1][4] = (float)bloomwidth / (float)bloomtexturewidth;
1439         texcoord2f[1][5] = 0;
1440         texcoord2f[1][6] = 0;
1441         texcoord2f[1][7] = 0;
1442
1443         R_ResetViewRendering();
1444         GL_DepthTest(false);
1445         R_Mesh_VertexPointer(vertex3f);
1446         R_Mesh_ColorPointer(NULL);
1447
1448         R_Mesh_TexCoordPointer(0, 2, texcoord2f[0]);
1449         R_Mesh_TexBind(0, R_GetTexture(r_bloom_texture_screen));
1450
1451         // copy view into the screen texture
1452         GL_ActiveTexture(0);
1453         CHECKGLERROR
1454         qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
1455         r_refdef.stats.bloom_copypixels += r_view.width * r_view.height;
1456
1457         // now scale it down to the bloom texture size
1458         CHECKGLERROR
1459         qglViewport(r_view.x, vid.height - (r_view.y + bloomheight), bloomwidth, bloomheight);CHECKGLERROR
1460         GL_BlendFunc(GL_ONE, GL_ZERO);
1461         GL_Color(1, 1, 1, 1);
1462         // TODO: optimize with multitexture or GLSL
1463         R_Mesh_Draw(0, 4, 2, polygonelements);
1464         r_refdef.stats.bloom_drawpixels += bloomwidth * bloomheight;
1465
1466         if (darken)
1467         {
1468                 // raise to a power of itself to darken it (this leaves the really
1469                 // bright stuff bright, and everything else becomes very dark)
1470                 // render multiple times with a multiply blendfunc to raise to a power
1471                 GL_BlendFunc(GL_DST_COLOR, GL_ZERO);
1472                 for (x = 1;x < r_bloom_power.integer;x++)
1473                 {
1474                         R_Mesh_Draw(0, 4, 2, polygonelements);
1475                         r_refdef.stats.bloom_drawpixels += bloomwidth * bloomheight;
1476                 }
1477         }
1478
1479         // we now have a darkened bloom image in the framebuffer
1480         // copy it into the bloom image texture for more processing
1481         R_Mesh_TexBind(0, R_GetTexture(r_bloom_texture_bloom));
1482         R_Mesh_TexCoordPointer(0, 2, texcoord2f[2]);
1483         GL_ActiveTexture(0);
1484         CHECKGLERROR
1485         qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + bloomheight), bloomwidth, bloomheight);CHECKGLERROR
1486         r_refdef.stats.bloom_copypixels += bloomwidth * bloomheight;
1487
1488         // blend on at multiple vertical offsets to achieve a vertical blur
1489         // TODO: do offset blends using GLSL
1490         range = r_bloom_blur.integer * bloomwidth / 320;
1491         GL_BlendFunc(GL_ONE, GL_ZERO);
1492         for (x = -range;x <= range;x++)
1493         {
1494                 xoffset = 0 / (float)bloomwidth * (float)bloomwidth / (float)screenwidth;
1495                 yoffset = x / (float)bloomheight * (float)bloomheight / (float)screenheight;
1496                 // compute a texcoord array with the specified x and y offset
1497                 texcoord2f[2][0] = xoffset+0;
1498                 texcoord2f[2][1] = yoffset+(float)bloomheight / (float)screenheight;
1499                 texcoord2f[2][2] = xoffset+(float)bloomwidth / (float)screenwidth;
1500                 texcoord2f[2][3] = yoffset+(float)bloomheight / (float)screenheight;
1501                 texcoord2f[2][4] = xoffset+(float)bloomwidth / (float)screenwidth;
1502                 texcoord2f[2][5] = yoffset+0;
1503                 texcoord2f[2][6] = xoffset+0;
1504                 texcoord2f[2][7] = yoffset+0;
1505                 // this r value looks like a 'dot' particle, fading sharply to
1506                 // black at the edges
1507                 // (probably not realistic but looks good enough)
1508                 r = r_bloom_intensity.value/(range*2+1)*(1 - x*x/(float)(range*range));
1509                 if (r < 0.01f)
1510                         continue;
1511                 GL_Color(r, r, r, 1);
1512                 R_Mesh_Draw(0, 4, 2, polygonelements);
1513                 r_refdef.stats.bloom_drawpixels += bloomwidth * bloomheight;
1514                 GL_BlendFunc(GL_ONE, GL_ONE);
1515         }
1516
1517         // copy the vertically blurred bloom view to a texture
1518         GL_ActiveTexture(0);
1519         CHECKGLERROR
1520         qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + bloomheight), bloomwidth, bloomheight);CHECKGLERROR
1521         r_refdef.stats.bloom_copypixels += bloomwidth * bloomheight;
1522
1523         // blend the vertically blurred image at multiple offsets horizontally
1524         // to finish the blur effect
1525         // TODO: do offset blends using GLSL
1526         range = r_bloom_blur.integer * bloomwidth / 320;
1527         GL_BlendFunc(GL_ONE, GL_ZERO);
1528         for (x = -range;x <= range;x++)
1529         {
1530                 xoffset = x / (float)bloomwidth * (float)bloomwidth / (float)screenwidth;
1531                 yoffset = 0 / (float)bloomheight * (float)bloomheight / (float)screenheight;
1532                 // compute a texcoord array with the specified x and y offset
1533                 texcoord2f[2][0] = xoffset+0;
1534                 texcoord2f[2][1] = yoffset+(float)bloomheight / (float)screenheight;
1535                 texcoord2f[2][2] = xoffset+(float)bloomwidth / (float)screenwidth;
1536                 texcoord2f[2][3] = yoffset+(float)bloomheight / (float)screenheight;
1537                 texcoord2f[2][4] = xoffset+(float)bloomwidth / (float)screenwidth;
1538                 texcoord2f[2][5] = yoffset+0;
1539                 texcoord2f[2][6] = xoffset+0;
1540                 texcoord2f[2][7] = yoffset+0;
1541                 // this r value looks like a 'dot' particle, fading sharply to
1542                 // black at the edges
1543                 // (probably not realistic but looks good enough)
1544                 r = r_bloom_intensity.value/(range*2+1)*(1 - x*x/(float)(range*range));
1545                 if (r < 0.01f)
1546                         continue;
1547                 GL_Color(r, r, r, 1);
1548                 R_Mesh_Draw(0, 4, 2, polygonelements);
1549                 r_refdef.stats.bloom_drawpixels += bloomwidth * bloomheight;
1550                 GL_BlendFunc(GL_ONE, GL_ONE);
1551         }
1552
1553         // copy the blurred bloom view to a texture
1554         GL_ActiveTexture(0);
1555         CHECKGLERROR
1556         qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + bloomheight), bloomwidth, bloomheight);CHECKGLERROR
1557         r_refdef.stats.bloom_copypixels += bloomwidth * bloomheight;
1558 }
1559
1560 void R_HDR_RenderBloomTexture(void)
1561 {
1562         int oldwidth, oldheight;
1563
1564         oldwidth = r_view.width;
1565         oldheight = r_view.height;
1566         r_view.width = bound(1, r_bloom_resolution.integer, min(r_view.width, gl_max_texture_size));
1567         r_view.height = r_view.width * oldheight / oldwidth;
1568
1569         // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer?  it might improve SLI performance.
1570         // FIXME: change global lightmapintensity and light intensity according to r_hdr_bloomintensity cvar
1571         // FIXME: change global lightmapintensity and light intensity according to r_hdr_scenebrightness cvar
1572         // TODO: add exposure compensation features
1573
1574         r_view.colorscale = r_hdr_bloomintensity.value * r_hdr_scenebrightness.value;
1575         R_RenderScene();
1576
1577         R_ResetViewRendering();
1578
1579         R_Bloom_MakeTexture(false);
1580
1581         R_ClearScreen();
1582         if (r_timereport_active)
1583                 R_TimeReport("clear");
1584
1585         // restore the view settings
1586         r_view.width = oldwidth;
1587         r_view.height = oldheight;
1588
1589         // go back to full view area
1590         R_ResetViewRendering();
1591 }
1592
1593 static void R_BlendView(void)
1594 {
1595         int screenwidth, screenheight;
1596         int bloomwidth, bloomheight;
1597         qboolean dobloom;
1598         qboolean dohdr;
1599         qboolean doblend;
1600         float vertex3f[12];
1601         float texcoord2f[3][8];
1602
1603         // set the (poorly named) screenwidth and screenheight variables to
1604         // a power of 2 at least as large as the screen, these will define the
1605         // size of the texture to allocate
1606         for (screenwidth = 1;screenwidth < vid.width;screenwidth *= 2);
1607         for (screenheight = 1;screenheight < vid.height;screenheight *= 2);
1608
1609         doblend = r_refdef.viewblend[3] >= 0.01f;
1610         dobloom = !r_hdr.integer && r_bloom.integer && screenwidth <= gl_max_texture_size && screenheight <= gl_max_texture_size && r_bloom_resolution.value >= 32 && r_bloom_power.integer >= 1 && r_bloom_power.integer < 100 && r_bloom_blur.value >= 0 && r_bloom_blur.value < 512;
1611         dohdr = r_hdr.integer && screenwidth <= gl_max_texture_size && screenheight <= gl_max_texture_size && r_bloom_resolution.value >= 32 && r_bloom_power.integer >= 1 && r_bloom_power.integer < 100 && r_bloom_blur.value >= 0 && r_bloom_blur.value < 512;
1612
1613         if (!dobloom && !dohdr && !doblend)
1614                 return;
1615
1616         // vertex coordinates for a quad that covers the screen exactly
1617         vertex3f[0] = 0;vertex3f[1] = 0;vertex3f[2] = 0;
1618         vertex3f[3] = 1;vertex3f[4] = 0;vertex3f[5] = 0;
1619         vertex3f[6] = 1;vertex3f[7] = 1;vertex3f[8] = 0;
1620         vertex3f[9] = 0;vertex3f[10] = 1;vertex3f[11] = 0;
1621
1622         // set bloomwidth and bloomheight to the bloom resolution that will be
1623         // used (often less than the screen resolution for faster rendering)
1624         bloomwidth = min(r_view.width, r_bloom_resolution.integer);
1625         bloomheight = min(r_view.height, bloomwidth * r_view.height / r_view.width);
1626         // set up a texcoord array for the full resolution screen image
1627         // (we have to keep this around to copy back during final render)
1628         texcoord2f[0][0] = 0;
1629         texcoord2f[0][1] = (float)r_view.height / (float)screenheight;
1630         texcoord2f[0][2] = (float)r_view.width / (float)screenwidth;
1631         texcoord2f[0][3] = (float)r_view.height / (float)screenheight;
1632         texcoord2f[0][4] = (float)r_view.width / (float)screenwidth;
1633         texcoord2f[0][5] = 0;
1634         texcoord2f[0][6] = 0;
1635         texcoord2f[0][7] = 0;
1636         // set up a texcoord array for the reduced resolution bloom image
1637         // (which will be additive blended over the screen image)
1638         texcoord2f[1][0] = 0;
1639         texcoord2f[1][1] = (float)bloomheight / (float)screenheight;
1640         texcoord2f[1][2] = (float)bloomwidth / (float)screenwidth;
1641         texcoord2f[1][3] = (float)bloomheight / (float)screenheight;
1642         texcoord2f[1][4] = (float)bloomwidth / (float)screenwidth;
1643         texcoord2f[1][5] = 0;
1644         texcoord2f[1][6] = 0;
1645         texcoord2f[1][7] = 0;
1646
1647         if (dohdr)
1648         {
1649                 // render high dynamic range bloom effect
1650                 // the bloom texture was made earlier this render, so we just need to
1651                 // blend it onto the screen...
1652                 R_ResetViewRendering();
1653                 GL_DepthTest(false);
1654                 R_Mesh_VertexPointer(vertex3f);
1655                 R_Mesh_ColorPointer(NULL);
1656                 GL_Color(1, 1, 1, 1);
1657                 GL_BlendFunc(GL_ONE, GL_ONE);
1658                 R_Mesh_TexBind(0, R_GetTexture(r_bloom_texture_bloom));
1659                 R_Mesh_TexCoordPointer(0, 2, texcoord2f[1]);
1660                 R_Mesh_Draw(0, 4, 2, polygonelements);
1661                 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
1662         }
1663         if (dobloom)
1664         {
1665                 // render simple bloom effect
1666                 // make the bloom texture
1667                 R_Bloom_MakeTexture(true);
1668                 // put the original screen image back in place and blend the bloom
1669                 // texture on it
1670                 R_ResetViewRendering();
1671                 GL_DepthTest(false);
1672                 R_Mesh_VertexPointer(vertex3f);
1673                 R_Mesh_ColorPointer(NULL);
1674                 GL_Color(1, 1, 1, 1);
1675                 GL_BlendFunc(GL_ONE, GL_ZERO);
1676                 // do both in one pass if possible
1677                 R_Mesh_TexBind(0, R_GetTexture(r_bloom_texture_screen));
1678                 R_Mesh_TexCoordPointer(0, 2, texcoord2f[0]);
1679                 if (r_textureunits.integer >= 2 && gl_combine.integer)
1680                 {
1681                         R_Mesh_TexCombine(1, GL_ADD, GL_ADD, 1, 1);
1682                         R_Mesh_TexBind(1, R_GetTexture(r_bloom_texture_bloom));
1683                         R_Mesh_TexCoordPointer(1, 2, texcoord2f[1]);
1684                 }
1685                 else
1686                 {
1687                         R_Mesh_Draw(0, 4, 2, polygonelements);
1688                         r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
1689                         // now blend on the bloom texture
1690                         GL_BlendFunc(GL_ONE, GL_ONE);
1691                         R_Mesh_TexBind(0, R_GetTexture(r_bloom_texture_bloom));
1692                         R_Mesh_TexCoordPointer(0, 2, texcoord2f[1]);
1693                 }
1694                 R_Mesh_Draw(0, 4, 2, polygonelements);
1695                 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
1696         }
1697         if (doblend)
1698         {
1699                 // apply a color tint to the whole view
1700                 R_ResetViewRendering();
1701                 GL_DepthTest(false);
1702                 R_Mesh_VertexPointer(vertex3f);
1703                 R_Mesh_ColorPointer(NULL);
1704                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1705                 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
1706                 R_Mesh_Draw(0, 4, 2, polygonelements);
1707         }
1708 }
1709
1710 void R_RenderScene(void);
1711
1712 matrix4x4_t r_waterscrollmatrix;
1713
1714 void R_UpdateVariables(void)
1715 {
1716         int i;
1717
1718         R_Textures_Frame();
1719
1720         r_refdef.farclip = 4096;
1721         if (r_refdef.worldmodel)
1722                 r_refdef.farclip += VectorDistance(r_refdef.worldmodel->normalmins, r_refdef.worldmodel->normalmaxs);
1723         r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
1724
1725         r_refdef.polygonfactor = 0;
1726         r_refdef.polygonoffset = 0;
1727         r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_shadow_polygonfactor.value;
1728         r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_shadow_polygonoffset.value;
1729
1730         r_refdef.rtworld = r_shadow_realtime_world.integer;
1731         r_refdef.rtworldshadows = r_shadow_realtime_world_shadows.integer && gl_stencil;
1732         r_refdef.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer;
1733         r_refdef.rtdlightshadows = r_refdef.rtdlight && (r_refdef.rtworld ? r_shadow_realtime_world_dlightshadows.integer : r_shadow_realtime_dlight_shadows.integer) && gl_stencil;
1734         r_refdef.lightmapintensity = r_refdef.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
1735         if (r_showsurfaces.integer)
1736         {
1737                 r_refdef.rtworld = false;
1738                 r_refdef.rtworldshadows = false;
1739                 r_refdef.rtdlight = false;
1740                 r_refdef.rtdlightshadows = false;
1741                 r_refdef.lightmapintensity = 0;
1742         }
1743
1744         if (gamemode == GAME_NEHAHRA)
1745         {
1746                 if (gl_fogenable.integer)
1747                 {
1748                         r_refdef.oldgl_fogenable = true;
1749                         r_refdef.fog_density = gl_fogdensity.value;
1750                         r_refdef.fog_red = gl_fogred.value;
1751                         r_refdef.fog_green = gl_foggreen.value;
1752                         r_refdef.fog_blue = gl_fogblue.value;
1753                 }
1754                 else if (r_refdef.oldgl_fogenable)
1755                 {
1756                         r_refdef.oldgl_fogenable = false;
1757                         r_refdef.fog_density = 0;
1758                         r_refdef.fog_red = 0;
1759                         r_refdef.fog_green = 0;
1760                         r_refdef.fog_blue = 0;
1761                 }
1762         }
1763         if (r_refdef.fog_density)
1764         {
1765                 r_refdef.fogcolor[0] = bound(0.0f, r_refdef.fog_red  , 1.0f);
1766                 r_refdef.fogcolor[1] = bound(0.0f, r_refdef.fog_green, 1.0f);
1767                 r_refdef.fogcolor[2] = bound(0.0f, r_refdef.fog_blue , 1.0f);
1768         }
1769         if (r_refdef.fog_density)
1770         {
1771                 r_refdef.fogenabled = true;
1772                 // this is the point where the fog reaches 0.9986 alpha, which we
1773                 // consider a good enough cutoff point for the texture
1774                 // (0.9986 * 256 == 255.6)
1775                 r_refdef.fogrange = 400 / r_refdef.fog_density;
1776                 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
1777                 r_refdef.fogtabledistmultiplier = FOGTABLEWIDTH * r_refdef.fograngerecip;
1778                 // fog color was already set
1779         }
1780         else
1781                 r_refdef.fogenabled = false;
1782
1783         // update some cached entity properties...
1784         for (i = 0;i < r_refdef.numentities;i++)
1785         {
1786                 entity_render_t *ent = r_refdef.entities[i];
1787                 R_UpdateEntityLighting(ent);
1788         }
1789 }
1790
1791 /*
1792 ================
1793 R_RenderView
1794 ================
1795 */
1796 void R_RenderView(void)
1797 {
1798         if (!r_refdef.entities/* || !r_refdef.worldmodel*/)
1799                 return; //Host_Error ("R_RenderView: NULL worldmodel");
1800
1801         CHECKGLERROR
1802         GL_ScissorTest(true);
1803         GL_DepthMask(true);
1804         if (r_timereport_active)
1805                 R_TimeReport("setup");
1806
1807         R_View_Update();
1808         if (r_timereport_active)
1809                 R_TimeReport("visibility");
1810
1811         R_ResetViewRendering();
1812
1813         R_ClearScreen();
1814         if (r_timereport_active)
1815                 R_TimeReport("clear");
1816
1817         // this produces a bloom texture to be used in R_BlendView() later
1818         if (r_hdr.integer)
1819                 R_HDR_RenderBloomTexture();
1820
1821         r_view.colorscale = r_hdr_scenebrightness.value;
1822         R_RenderScene();
1823
1824         R_BlendView();
1825         if (r_timereport_active)
1826                 R_TimeReport("blendview");
1827
1828         GL_Scissor(0, 0, vid.width, vid.height);
1829         GL_ScissorTest(false);
1830         CHECKGLERROR
1831 }
1832
1833 extern void R_DrawLightningBeams (void);
1834 extern void VM_AddPolygonsToMeshQueue (void);
1835 extern void R_DrawPortals (void);
1836 void R_RenderScene(void)
1837 {
1838         DrawQ_Finish();
1839
1840         // don't let sound skip if going slow
1841         if (r_refdef.extraupdate)
1842                 S_ExtraUpdate ();
1843
1844         CHECKGLERROR
1845         if (gl_support_fragment_shader)
1846         {
1847                 qglUseProgramObjectARB(0);CHECKGLERROR
1848         }
1849         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
1850         qglPolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
1851         qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
1852
1853         R_ResetViewRendering();
1854
1855         R_MeshQueue_BeginScene();
1856
1857         if (r_refdef.rtworldshadows || r_refdef.rtdlightshadows)
1858                 GL_SetupView_Mode_PerspectiveInfiniteFarClip(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip);
1859         else
1860                 GL_SetupView_Mode_Perspective(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip, r_refdef.farclip);
1861
1862         GL_SetupView_Orientation_FromEntity(&r_view.matrix);
1863
1864         R_Shadow_UpdateWorldLightSelection();
1865
1866         R_SkyStartFrame();
1867
1868         Matrix4x4_CreateTranslate(&r_waterscrollmatrix, sin(r_refdef.time) * 0.025 * r_waterscroll.value, sin(r_refdef.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
1869
1870         if (cl.csqc_vidvars.drawworld)
1871         {
1872                 // don't let sound skip if going slow
1873                 if (r_refdef.extraupdate)
1874                         S_ExtraUpdate ();
1875
1876                 if (r_refdef.worldmodel && r_refdef.worldmodel->DrawSky)
1877                 {
1878                         r_refdef.worldmodel->DrawSky(r_refdef.worldentity);
1879                         if (r_timereport_active)
1880                                 R_TimeReport("worldsky");
1881                 }
1882
1883                 if (R_DrawBrushModelsSky() && r_timereport_active)
1884                         R_TimeReport("bmodelsky");
1885
1886                 if (r_refdef.worldmodel && r_refdef.worldmodel->Draw)
1887                 {
1888                         r_refdef.worldmodel->Draw(r_refdef.worldentity);
1889                         if (r_timereport_active)
1890                                 R_TimeReport("world");
1891                 }
1892         }
1893
1894         // don't let sound skip if going slow
1895         if (r_refdef.extraupdate)
1896                 S_ExtraUpdate ();
1897
1898         R_DrawModels();
1899         if (r_timereport_active)
1900                 R_TimeReport("models");
1901
1902         // don't let sound skip if going slow
1903         if (r_refdef.extraupdate)
1904                 S_ExtraUpdate ();
1905
1906         R_ShadowVolumeLighting(false);
1907         if (r_timereport_active)
1908                 R_TimeReport("rtlights");
1909
1910         // don't let sound skip if going slow
1911         if (r_refdef.extraupdate)
1912                 S_ExtraUpdate ();
1913
1914         if (cl.csqc_vidvars.drawworld)
1915         {
1916                 R_DrawLightningBeams();
1917                 if (r_timereport_active)
1918                         R_TimeReport("lightning");
1919
1920                 R_DrawParticles();
1921                 if (r_timereport_active)
1922                         R_TimeReport("particles");
1923
1924                 R_DrawExplosions();
1925                 if (r_timereport_active)
1926                         R_TimeReport("explosions");
1927         }
1928
1929         if (gl_support_fragment_shader)
1930         {
1931                 qglUseProgramObjectARB(0);CHECKGLERROR
1932         }
1933         VM_AddPolygonsToMeshQueue();
1934
1935         if (r_drawportals.integer)
1936         {
1937                 R_DrawPortals();
1938                 if (r_timereport_active)
1939                         R_TimeReport("portals");
1940         }
1941
1942         if (gl_support_fragment_shader)
1943         {
1944                 qglUseProgramObjectARB(0);CHECKGLERROR
1945         }
1946         R_MeshQueue_RenderTransparent();
1947         if (r_timereport_active)
1948                 R_TimeReport("drawtrans");
1949
1950         if (gl_support_fragment_shader)
1951         {
1952                 qglUseProgramObjectARB(0);CHECKGLERROR
1953         }
1954
1955         if (cl.csqc_vidvars.drawworld)
1956         {
1957                 R_DrawCoronas();
1958                 if (r_timereport_active)
1959                         R_TimeReport("coronas");
1960         }
1961
1962         // don't let sound skip if going slow
1963         if (r_refdef.extraupdate)
1964                 S_ExtraUpdate ();
1965
1966         CHECKGLERROR
1967         if (gl_support_fragment_shader)
1968         {
1969                 qglUseProgramObjectARB(0);CHECKGLERROR
1970         }
1971         qglPolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
1972         qglDisable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
1973 }
1974
1975 /*
1976 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
1977 {
1978         int i;
1979         float *v, *c, f1, f2, diff[3], vertex3f[8*3], color4f[8*4];
1980         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1981         GL_DepthMask(false);
1982         GL_DepthTest(true);
1983         R_Mesh_Matrix(&identitymatrix);
1984
1985         vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2];
1986         vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
1987         vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
1988         vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
1989         vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
1990         vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
1991         vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
1992         vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
1993         R_FillColors(color, 8, cr, cg, cb, ca);
1994         if (r_refdef.fogenabled)
1995         {
1996                 for (i = 0, v = vertex, c = color;i < 8;i++, v += 4, c += 4)
1997                 {
1998                         f2 = VERTEXFOGTABLE(VectorDistance(v, r_view.origin));
1999                         f1 = 1 - f2;
2000                         c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
2001                         c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
2002                         c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
2003                 }
2004         }
2005         R_Mesh_VertexPointer(vertex3f);
2006         R_Mesh_ColorPointer(color);
2007         R_Mesh_ResetTextureState();
2008         R_Mesh_Draw(8, 12);
2009 }
2010 */
2011
2012 int nomodelelements[24] =
2013 {
2014         5, 2, 0,
2015         5, 1, 2,
2016         5, 0, 3,
2017         5, 3, 1,
2018         0, 2, 4,
2019         2, 1, 4,
2020         3, 0, 4,
2021         1, 3, 4
2022 };
2023
2024 float nomodelvertex3f[6*3] =
2025 {
2026         -16,   0,   0,
2027          16,   0,   0,
2028           0, -16,   0,
2029           0,  16,   0,
2030           0,   0, -16,
2031           0,   0,  16
2032 };
2033
2034 float nomodelcolor4f[6*4] =
2035 {
2036         0.0f, 0.0f, 0.5f, 1.0f,
2037         0.0f, 0.0f, 0.5f, 1.0f,
2038         0.0f, 0.5f, 0.0f, 1.0f,
2039         0.0f, 0.5f, 0.0f, 1.0f,
2040         0.5f, 0.0f, 0.0f, 1.0f,
2041         0.5f, 0.0f, 0.0f, 1.0f
2042 };
2043
2044 void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
2045 {
2046         int i;
2047         float f1, f2, *c;
2048         float color4f[6*4];
2049         // this is only called once per entity so numsurfaces is always 1, and
2050         // surfacelist is always {0}, so this code does not handle batches
2051         R_Mesh_Matrix(&ent->matrix);
2052
2053         if (ent->flags & EF_ADDITIVE)
2054         {
2055                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2056                 GL_DepthMask(false);
2057         }
2058         else if (ent->alpha < 1)
2059         {
2060                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2061                 GL_DepthMask(false);
2062         }
2063         else
2064         {
2065                 GL_BlendFunc(GL_ONE, GL_ZERO);
2066                 GL_DepthMask(true);
2067         }
2068         GL_DepthTest(!(ent->effects & EF_NODEPTHTEST));
2069         R_Mesh_VertexPointer(nomodelvertex3f);
2070         if (r_refdef.fogenabled)
2071         {
2072                 vec3_t org;
2073                 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
2074                 R_Mesh_ColorPointer(color4f);
2075                 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
2076                 f2 = VERTEXFOGTABLE(VectorDistance(org, r_view.origin));
2077                 f1 = 1 - f2;
2078                 for (i = 0, c = color4f;i < 6;i++, c += 4)
2079                 {
2080                         c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
2081                         c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
2082                         c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
2083                         c[3] *= ent->alpha;
2084                 }
2085         }
2086         else if (ent->alpha != 1)
2087         {
2088                 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
2089                 R_Mesh_ColorPointer(color4f);
2090                 for (i = 0, c = color4f;i < 6;i++, c += 4)
2091                         c[3] *= ent->alpha;
2092         }
2093         else
2094                 R_Mesh_ColorPointer(nomodelcolor4f);
2095         R_Mesh_ResetTextureState();
2096         R_Mesh_Draw(0, 6, 8, nomodelelements);
2097 }
2098
2099 void R_DrawNoModel(entity_render_t *ent)
2100 {
2101         vec3_t org;
2102         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
2103         //if ((ent->effects & EF_ADDITIVE) || (ent->alpha < 1))
2104                 R_MeshQueue_AddTransparent(ent->effects & EF_NODEPTHTEST ? r_view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, r_shadow_rtlight);
2105         //else
2106         //      R_DrawNoModelCallback(ent, 0);
2107 }
2108
2109 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
2110 {
2111         vec3_t right1, right2, diff, normal;
2112
2113         VectorSubtract (org2, org1, normal);
2114
2115         // calculate 'right' vector for start
2116         VectorSubtract (r_view.origin, org1, diff);
2117         CrossProduct (normal, diff, right1);
2118         VectorNormalize (right1);
2119
2120         // calculate 'right' vector for end
2121         VectorSubtract (r_view.origin, org2, diff);
2122         CrossProduct (normal, diff, right2);
2123         VectorNormalize (right2);
2124
2125         vert[ 0] = org1[0] + width * right1[0];
2126         vert[ 1] = org1[1] + width * right1[1];
2127         vert[ 2] = org1[2] + width * right1[2];
2128         vert[ 3] = org1[0] - width * right1[0];
2129         vert[ 4] = org1[1] - width * right1[1];
2130         vert[ 5] = org1[2] - width * right1[2];
2131         vert[ 6] = org2[0] - width * right2[0];
2132         vert[ 7] = org2[1] - width * right2[1];
2133         vert[ 8] = org2[2] - width * right2[2];
2134         vert[ 9] = org2[0] + width * right2[0];
2135         vert[10] = org2[1] + width * right2[1];
2136         vert[11] = org2[2] + width * right2[2];
2137 }
2138
2139 float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
2140
2141 void R_DrawSprite(int blendfunc1, int blendfunc2, rtexture_t *texture, rtexture_t *fogtexture, int depthdisable, const vec3_t origin, const vec3_t left, const vec3_t up, float scalex1, float scalex2, float scaley1, float scaley2, float cr, float cg, float cb, float ca)
2142 {
2143         float fog = 0.0f, ifog;
2144         float vertex3f[12];
2145
2146         if (r_refdef.fogenabled)
2147                 fog = VERTEXFOGTABLE(VectorDistance(origin, r_view.origin));
2148         ifog = 1 - fog;
2149
2150         R_Mesh_Matrix(&identitymatrix);
2151         GL_BlendFunc(blendfunc1, blendfunc2);
2152         GL_DepthMask(false);
2153         GL_DepthTest(!depthdisable);
2154
2155         vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
2156         vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
2157         vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
2158         vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
2159         vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
2160         vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
2161         vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
2162         vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
2163         vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
2164         vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
2165         vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
2166         vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
2167
2168         R_Mesh_VertexPointer(vertex3f);
2169         R_Mesh_ColorPointer(NULL);
2170         R_Mesh_ResetTextureState();
2171         R_Mesh_TexBind(0, R_GetTexture(texture));
2172         R_Mesh_TexCoordPointer(0, 2, spritetexcoord2f);
2173         // FIXME: fixed function path can't properly handle r_view.colorscale > 1
2174         GL_Color(cr * ifog * r_view.colorscale, cg * ifog * r_view.colorscale, cb * ifog * r_view.colorscale, ca);
2175         R_Mesh_Draw(0, 4, 2, polygonelements);
2176
2177         if (blendfunc2 == GL_ONE_MINUS_SRC_ALPHA)
2178         {
2179                 R_Mesh_TexBind(0, R_GetTexture(fogtexture));
2180                 GL_BlendFunc(blendfunc1, GL_ONE);
2181                 GL_Color(r_refdef.fogcolor[0] * fog * r_view.colorscale, r_refdef.fogcolor[1] * fog * r_view.colorscale, r_refdef.fogcolor[2] * fog * r_view.colorscale, ca);
2182                 R_Mesh_Draw(0, 4, 2, polygonelements);
2183         }
2184 }
2185
2186 int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
2187 {
2188         int i;
2189         float *vertex3f;
2190         float v[3];
2191         VectorSet(v, x, y, z);
2192         for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
2193                 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
2194                         break;
2195         if (i == mesh->numvertices)
2196         {
2197                 if (mesh->numvertices < mesh->maxvertices)
2198                 {
2199                         VectorCopy(v, vertex3f);
2200                         mesh->numvertices++;
2201                 }
2202                 return mesh->numvertices;
2203         }
2204         else
2205                 return i;
2206 }
2207
2208 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
2209 {
2210         int i;
2211         int *e, element[3];
2212         element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
2213         element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
2214         e = mesh->element3i + mesh->numtriangles * 3;
2215         for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
2216         {
2217                 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
2218                 if (mesh->numtriangles < mesh->maxtriangles)
2219                 {
2220                         *e++ = element[0];
2221                         *e++ = element[1];
2222                         *e++ = element[2];
2223                         mesh->numtriangles++;
2224                 }
2225                 element[1] = element[2];
2226         }
2227 }
2228
2229 void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
2230 {
2231         int i;
2232         int *e, element[3];
2233         element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
2234         element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
2235         e = mesh->element3i + mesh->numtriangles * 3;
2236         for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
2237         {
2238                 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
2239                 if (mesh->numtriangles < mesh->maxtriangles)
2240                 {
2241                         *e++ = element[0];
2242                         *e++ = element[1];
2243                         *e++ = element[2];
2244                         mesh->numtriangles++;
2245                 }
2246                 element[1] = element[2];
2247         }
2248 }
2249
2250 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
2251 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
2252 {
2253         int planenum, planenum2;
2254         int w;
2255         int tempnumpoints;
2256         mplane_t *plane, *plane2;
2257         double maxdist;
2258         double temppoints[2][256*3];
2259         // figure out how large a bounding box we need to properly compute this brush
2260         maxdist = 0;
2261         for (w = 0;w < numplanes;w++)
2262                 maxdist = max(maxdist, planes[w].dist);
2263         // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
2264         maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
2265         for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
2266         {
2267                 w = 0;
2268                 tempnumpoints = 4;
2269                 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
2270                 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
2271                 {
2272                         if (planenum2 == planenum)
2273                                 continue;
2274                         PolygonD_Divide(tempnumpoints, temppoints[w], plane2->normal[0], plane2->normal[1], plane2->normal[2], plane2->dist, R_MESH_PLANE_DIST_EPSILON, 0, NULL, NULL, 256, temppoints[!w], &tempnumpoints, NULL);
2275                         w = !w;
2276                 }
2277                 if (tempnumpoints < 3)
2278                         continue;
2279                 // generate elements forming a triangle fan for this polygon
2280                 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
2281         }
2282 }
2283
2284 static void R_DrawCollisionBrush(const colbrushf_t *brush)
2285 {
2286         int i;
2287         R_Mesh_VertexPointer(brush->points->v);
2288         i = (int)(((size_t)brush) / sizeof(colbrushf_t));
2289         GL_Color((i & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 5) & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 10) & 31) * (1.0f / 32.0f) * r_view.colorscale, 0.2f);
2290         GL_LockArrays(0, brush->numpoints);
2291         R_Mesh_Draw(0, brush->numpoints, brush->numtriangles, brush->elements);
2292         GL_LockArrays(0, 0);
2293 }
2294
2295 static void R_DrawCollisionSurface(const entity_render_t *ent, const msurface_t *surface)
2296 {
2297         int i;
2298         if (!surface->num_collisiontriangles)
2299                 return;
2300         R_Mesh_VertexPointer(surface->data_collisionvertex3f);
2301         i = (int)(((size_t)surface) / sizeof(msurface_t));
2302         GL_Color((i & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 5) & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 10) & 31) * (1.0f / 32.0f) * r_view.colorscale, 0.2f);
2303         GL_LockArrays(0, surface->num_collisionvertices);
2304         R_Mesh_Draw(0, surface->num_collisionvertices, surface->num_collisiontriangles, surface->data_collisionelement3i);
2305         GL_LockArrays(0, 0);
2306 }
2307
2308 static void R_Texture_AddLayer(texture_t *t, qboolean depthmask, int blendfunc1, int blendfunc2, texturelayertype_t type, rtexture_t *texture, const matrix4x4_t *matrix, float r, float g, float b, float a)
2309 {
2310         texturelayer_t *layer;
2311         layer = t->currentlayers + t->currentnumlayers++;
2312         layer->type = type;
2313         layer->depthmask = depthmask;
2314         layer->blendfunc1 = blendfunc1;
2315         layer->blendfunc2 = blendfunc2;
2316         layer->texture = texture;
2317         layer->texmatrix = *matrix;
2318         layer->color[0] = r * r_view.colorscale;
2319         layer->color[1] = g * r_view.colorscale;
2320         layer->color[2] = b * r_view.colorscale;
2321         layer->color[3] = a;
2322 }
2323
2324 void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
2325 {
2326         // FIXME: identify models using a better check than ent->model->brush.shadowmesh
2327         //int lightmode = ((ent->effects & EF_FULLBRIGHT) || ent->model->brush.shadowmesh) ? 0 : 2;
2328
2329         // switch to an alternate material if this is a q1bsp animated material
2330         {
2331                 texture_t *texture = t;
2332                 model_t *model = ent->model;
2333                 int s = ent->skinnum;
2334                 if ((unsigned int)s >= (unsigned int)model->numskins)
2335                         s = 0;
2336                 if (model->skinscenes)
2337                 {
2338                         if (model->skinscenes[s].framecount > 1)
2339                                 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
2340                         else
2341                                 s = model->skinscenes[s].firstframe;
2342                 }
2343                 if (s > 0)
2344                         t = t + s * model->num_surfaces;
2345                 if (t->animated)
2346                 {
2347                         // use an alternate animation if the entity's frame is not 0,
2348                         // and only if the texture has an alternate animation
2349                         if (ent->frame != 0 && t->anim_total[1])
2350                                 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[1]) : 0];
2351                         else
2352                                 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[0]) : 0];
2353                 }
2354                 texture->currentframe = t;
2355         }
2356
2357         // pick a new currentskinframe if the material is animated
2358         if (t->numskinframes >= 2)
2359                 t->currentskinframe = t->skinframes + ((int)(t->skinframerate * (cl.time - ent->frame2time)) % t->numskinframes);
2360
2361         t->currentmaterialflags = t->basematerialflags;
2362         t->currentalpha = ent->alpha;
2363         if (t->basematerialflags & MATERIALFLAG_WATERALPHA)
2364                 t->currentalpha *= r_wateralpha.value;
2365         if (!(ent->flags & RENDER_LIGHT))
2366                 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
2367         if (ent->effects & EF_ADDITIVE)
2368                 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT;
2369         else if (t->currentalpha < 1)
2370                 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT;
2371         if (ent->effects & EF_NODEPTHTEST)
2372                 t->currentmaterialflags |= MATERIALFLAG_NODEPTHTEST;
2373         if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
2374                 t->currenttexmatrix = r_waterscrollmatrix;
2375         else
2376                 t->currenttexmatrix = identitymatrix;
2377
2378         t->colormapping = VectorLength2(ent->colormap_pantscolor) + VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f);
2379         t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
2380         t->glosstexture = r_texture_white;
2381         t->specularpower = 8;
2382         t->specularscale = 0;
2383         if (r_shadow_gloss.integer > 0)
2384         {
2385                 if (t->currentskinframe->gloss)
2386                 {
2387                         if (r_shadow_glossintensity.value > 0)
2388                         {
2389                                 t->glosstexture = t->currentskinframe->gloss;
2390                                 t->specularscale = r_shadow_glossintensity.value;
2391                         }
2392                 }
2393                 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
2394                         t->specularscale = r_shadow_gloss2intensity.value;
2395         }
2396
2397         t->currentnumlayers = 0;
2398         if (!(t->currentmaterialflags & MATERIALFLAG_NODRAW))
2399         {
2400                 if (gl_lightmaps.integer)
2401                         R_Texture_AddLayer(t, true, GL_ONE, GL_ZERO, TEXTURELAYERTYPE_LITTEXTURE, r_texture_white, &identitymatrix, 1, 1, 1, 1);
2402                 else if (!(t->currentmaterialflags & MATERIALFLAG_SKY))
2403                 {
2404                         int blendfunc1, blendfunc2, depthmask;
2405                         if (t->currentmaterialflags & MATERIALFLAG_ADD)
2406                         {
2407                                 blendfunc1 = GL_SRC_ALPHA;
2408                                 blendfunc2 = GL_ONE;
2409                         }
2410                         else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
2411                         {
2412                                 blendfunc1 = GL_SRC_ALPHA;
2413                                 blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
2414                         }
2415                         else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
2416                         {
2417                                 blendfunc1 = t->customblendfunc[0];
2418                                 blendfunc2 = t->customblendfunc[1];
2419                         }
2420                         else
2421                         {
2422                                 blendfunc1 = GL_ONE;
2423                                 blendfunc2 = GL_ZERO;
2424                         }
2425                         depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
2426                         if (t->currentmaterialflags & (MATERIALFLAG_WATER | MATERIALFLAG_WALL))
2427                         {
2428                                 rtexture_t *currentbasetexture;
2429                                 int layerflags = 0;
2430                                 if (r_refdef.fogenabled && (t->currentmaterialflags & MATERIALFLAG_BLENDED))
2431                                         layerflags |= TEXTURELAYERFLAG_FOGDARKEN;
2432                                 currentbasetexture = (VectorLength2(ent->colormap_pantscolor) + VectorLength2(ent->colormap_shirtcolor) < (1.0f / 1048576.0f) && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
2433                                 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
2434                                 {
2435                                         // fullbright is not affected by r_refdef.lightmapintensity
2436                                         R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_TEXTURE, currentbasetexture, &t->currenttexmatrix, ent->colormod[0], ent->colormod[1], ent->colormod[2], t->currentalpha);
2437                                         if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->currentskinframe->pants)
2438                                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->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);
2439                                         if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->currentskinframe->shirt)
2440                                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->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);
2441                                 }
2442                                 else
2443                                 {
2444                                         float colorscale;
2445                                         colorscale = 2;
2446                                         // q3bsp has no lightmap updates, so the lightstylevalue that
2447                                         // would normally be baked into the lightmap must be
2448                                         // applied to the color
2449                                         if (ent->model->type == mod_brushq3)
2450                                                 colorscale *= r_refdef.lightstylevalue[0] * (1.0f / 256.0f);
2451                                         colorscale *= r_refdef.lightmapintensity;
2452                                         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);
2453                                         if (r_ambient.value >= (1.0f/64.0f))
2454                                                 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);
2455                                         if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->currentskinframe->pants)
2456                                         {
2457                                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->currentskinframe->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);
2458                                                 if (r_ambient.value >= (1.0f/64.0f))
2459                                                         R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->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);
2460                                         }
2461                                         if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->currentskinframe->shirt)
2462                                         {
2463                                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->currentskinframe->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);
2464                                                 if (r_ambient.value >= (1.0f/64.0f))
2465                                                         R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->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);
2466                                         }
2467                                 }
2468                                 if (t->currentskinframe->glow != NULL)
2469                                         R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->glow, &t->currenttexmatrix, r_hdr_glowintensity.value, r_hdr_glowintensity.value, r_hdr_glowintensity.value, t->currentalpha);
2470                                 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
2471                                 {
2472                                         // if this is opaque use alpha blend which will darken the earlier
2473                                         // passes cheaply.
2474                                         //
2475                                         // if this is an alpha blended material, all the earlier passes
2476                                         // were darkened by fog already, so we only need to add the fog
2477                                         // color ontop through the fog mask texture
2478                                         //
2479                                         // if this is an additive blended material, all the earlier passes
2480                                         // were darkened by fog already, and we should not add fog color
2481                                         // (because the background was not darkened, there is no fog color
2482                                         // that was lost behind it).
2483                                         R_Texture_AddLayer(t, false, GL_SRC_ALPHA, (t->currentmaterialflags & MATERIALFLAG_BLENDED) ? GL_ONE : GL_ONE_MINUS_SRC_ALPHA, TEXTURELAYERTYPE_FOG, t->currentskinframe->fog, &identitymatrix, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], t->currentalpha);
2484                                 }
2485                         }
2486                 }
2487         }
2488 }
2489
2490 void R_UpdateAllTextureInfo(entity_render_t *ent)
2491 {
2492         int i;
2493         if (ent->model)
2494                 for (i = 0;i < ent->model->num_textures;i++)
2495                         R_UpdateTextureInfo(ent, ent->model->data_textures + i);
2496 }
2497
2498 int rsurface_array_size = 0;
2499 float *rsurface_array_modelvertex3f = NULL;
2500 float *rsurface_array_modelsvector3f = NULL;
2501 float *rsurface_array_modeltvector3f = NULL;
2502 float *rsurface_array_modelnormal3f = NULL;
2503 float *rsurface_array_deformedvertex3f = NULL;
2504 float *rsurface_array_deformedsvector3f = NULL;
2505 float *rsurface_array_deformedtvector3f = NULL;
2506 float *rsurface_array_deformednormal3f = NULL;
2507 float *rsurface_array_color4f = NULL;
2508 float *rsurface_array_texcoord3f = NULL;
2509
2510 void R_Mesh_ResizeArrays(int newvertices)
2511 {
2512         float *base;
2513         if (rsurface_array_size >= newvertices)
2514                 return;
2515         if (rsurface_array_modelvertex3f)
2516                 Mem_Free(rsurface_array_modelvertex3f);
2517         rsurface_array_size = (newvertices + 1023) & ~1023;
2518         base = (float *)Mem_Alloc(r_main_mempool, rsurface_array_size * sizeof(float[31]));
2519         rsurface_array_modelvertex3f     = base + rsurface_array_size * 0;
2520         rsurface_array_modelsvector3f    = base + rsurface_array_size * 3;
2521         rsurface_array_modeltvector3f    = base + rsurface_array_size * 6;
2522         rsurface_array_modelnormal3f     = base + rsurface_array_size * 9;
2523         rsurface_array_deformedvertex3f  = base + rsurface_array_size * 12;
2524         rsurface_array_deformedsvector3f = base + rsurface_array_size * 15;
2525         rsurface_array_deformedtvector3f = base + rsurface_array_size * 18;
2526         rsurface_array_deformednormal3f  = base + rsurface_array_size * 21;
2527         rsurface_array_texcoord3f        = base + rsurface_array_size * 24;
2528         rsurface_array_color4f           = base + rsurface_array_size * 27;
2529 }
2530
2531 float *rsurface_modelvertex3f;
2532 float *rsurface_modelsvector3f;
2533 float *rsurface_modeltvector3f;
2534 float *rsurface_modelnormal3f;
2535 float *rsurface_vertex3f;
2536 float *rsurface_svector3f;
2537 float *rsurface_tvector3f;
2538 float *rsurface_normal3f;
2539 float *rsurface_lightmapcolor4f;
2540 vec3_t rsurface_modelorg;
2541 qboolean rsurface_generatedvertex;
2542 const entity_render_t *rsurface_entity;
2543 const model_t *rsurface_model;
2544 texture_t *rsurface_texture;
2545 rtexture_t *rsurface_lightmaptexture;
2546 rsurfmode_t rsurface_mode;
2547 texture_t *rsurface_glsl_texture;
2548 qboolean rsurface_glsl_uselightmap;
2549
2550 void RSurf_ActiveEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
2551 {
2552         Matrix4x4_Transform(&ent->inversematrix, r_view.origin, rsurface_modelorg);
2553         rsurface_entity = ent;
2554         rsurface_model = ent->model;
2555         if (rsurface_array_size < rsurface_model->surfmesh.num_vertices)
2556                 R_Mesh_ResizeArrays(rsurface_model->surfmesh.num_vertices);
2557         R_Mesh_Matrix(&ent->matrix);
2558         Matrix4x4_Transform(&ent->inversematrix, r_view.origin, rsurface_modelorg);
2559         if ((rsurface_entity->frameblend[0].lerp != 1 || rsurface_entity->frameblend[0].frame != 0) && rsurface_model->surfmesh.isanimated)
2560         {
2561                 if (wanttangents)
2562                 {
2563                         rsurface_modelvertex3f = rsurface_array_modelvertex3f;
2564                         rsurface_modelsvector3f = rsurface_array_modelsvector3f;
2565                         rsurface_modeltvector3f = rsurface_array_modeltvector3f;
2566                         rsurface_modelnormal3f = rsurface_array_modelnormal3f;
2567                         Mod_Alias_GetMesh_Vertices(rsurface_model, rsurface_entity->frameblend, rsurface_array_modelvertex3f, rsurface_array_modelnormal3f, rsurface_array_modelsvector3f, rsurface_array_modeltvector3f);
2568                 }
2569                 else if (wantnormals)
2570                 {
2571                         rsurface_modelvertex3f = rsurface_array_modelvertex3f;
2572                         rsurface_modelsvector3f = NULL;
2573                         rsurface_modeltvector3f = NULL;
2574                         rsurface_modelnormal3f = rsurface_array_modelnormal3f;
2575                         Mod_Alias_GetMesh_Vertices(rsurface_model, rsurface_entity->frameblend, rsurface_array_modelvertex3f, rsurface_array_modelnormal3f, NULL, NULL);
2576                 }
2577                 else
2578                 {
2579                         rsurface_modelvertex3f = rsurface_array_modelvertex3f;
2580                         rsurface_modelsvector3f = NULL;
2581                         rsurface_modeltvector3f = NULL;
2582                         rsurface_modelnormal3f = NULL;
2583                         Mod_Alias_GetMesh_Vertices(rsurface_model, rsurface_entity->frameblend, rsurface_array_modelvertex3f, NULL, NULL, NULL);
2584                 }
2585                 rsurface_generatedvertex = true;
2586         }
2587         else
2588         {
2589                 rsurface_modelvertex3f  = rsurface_model->surfmesh.data_vertex3f;
2590                 rsurface_modelsvector3f = rsurface_model->surfmesh.data_svector3f;
2591                 rsurface_modeltvector3f = rsurface_model->surfmesh.data_tvector3f;
2592                 rsurface_modelnormal3f  = rsurface_model->surfmesh.data_normal3f;
2593                 rsurface_generatedvertex = false;
2594         }
2595         rsurface_vertex3f  = rsurface_modelvertex3f;
2596         rsurface_svector3f = rsurface_modelsvector3f;
2597         rsurface_tvector3f = rsurface_modeltvector3f;
2598         rsurface_normal3f  = rsurface_modelnormal3f;
2599         rsurface_mode = RSURFMODE_NONE;
2600         rsurface_lightmaptexture = NULL;
2601         rsurface_texture = NULL;
2602         rsurface_glsl_texture = NULL;
2603         rsurface_glsl_uselightmap = false;
2604 }
2605
2606 void RSurf_CleanUp(void)
2607 {
2608         CHECKGLERROR
2609         if (rsurface_mode == RSURFMODE_GLSL)
2610         {
2611                 qglUseProgramObjectARB(0);CHECKGLERROR
2612         }
2613         GL_AlphaTest(false);
2614         rsurface_mode = RSURFMODE_NONE;
2615         rsurface_lightmaptexture = NULL;
2616         rsurface_texture = NULL;
2617         rsurface_glsl_texture = NULL;
2618         rsurface_glsl_uselightmap = false;
2619 }
2620
2621 void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, msurface_t **texturesurfacelist)
2622 {
2623         // 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
2624         if (rsurface_generatedvertex)
2625         {
2626                 if (rsurface_texture->textureflags & (Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2))
2627                         generatetangents = true;
2628                 if (generatetangents)
2629                         generatenormals = true;
2630                 if (generatenormals && !rsurface_modelnormal3f)
2631                 {
2632                         rsurface_normal3f = rsurface_modelnormal3f = rsurface_array_modelnormal3f;
2633                         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);
2634                 }
2635                 if (generatetangents && !rsurface_modelsvector3f)
2636                 {
2637                         rsurface_svector3f = rsurface_modelsvector3f = rsurface_array_modelsvector3f;
2638                         rsurface_tvector3f = rsurface_modeltvector3f = rsurface_array_modeltvector3f;
2639                         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);
2640                 }
2641         }
2642         // 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)
2643         if (rsurface_texture->textureflags & (Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2))
2644         {
2645                 int texturesurfaceindex;
2646                 float center[3], forward[3], right[3], up[3], v[4][3];
2647                 matrix4x4_t matrix1, imatrix1;
2648                 Matrix4x4_Transform(&rsurface_entity->inversematrix, r_view.forward, forward);
2649                 Matrix4x4_Transform(&rsurface_entity->inversematrix, r_view.right, right);
2650                 Matrix4x4_Transform(&rsurface_entity->inversematrix, r_view.up, up);
2651                 // make deformed versions of only the model vertices used by the specified surfaces
2652                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2653                 {
2654                         int i, j;
2655                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2656                         // a single autosprite surface can contain multiple sprites...
2657                         for (j = 0;j < surface->num_vertices - 3;j += 4)
2658                         {
2659                                 VectorClear(center);
2660                                 for (i = 0;i < 4;i++)
2661                                         VectorAdd(center, (rsurface_modelvertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
2662                                 VectorScale(center, 0.25f, center);
2663                                 if (rsurface_texture->textureflags & Q3TEXTUREFLAG_AUTOSPRITE2)
2664                                 {
2665                                         forward[0] = rsurface_modelorg[0] - center[0];
2666                                         forward[1] = rsurface_modelorg[1] - center[1];
2667                                         forward[2] = 0;
2668                                         VectorNormalize(forward);
2669                                         right[0] = forward[1];
2670                                         right[1] = -forward[0];
2671                                         right[2] = 0;
2672                                         VectorSet(up, 0, 0, 1);
2673                                 }
2674                                 // FIXME: calculate vectors from triangle edges instead of using texture vectors as an easy way out?
2675                                 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);
2676                                 Matrix4x4_Invert_Simple(&imatrix1, &matrix1);
2677                                 for (i = 0;i < 4;i++)
2678                                         Matrix4x4_Transform(&imatrix1, (rsurface_modelvertex3f + 3 * surface->num_firstvertex) + (j+i)*3, v[i]);
2679                                 for (i = 0;i < 4;i++)
2680                                         VectorMAMAMAM(1, center, v[i][0], forward, v[i][1], right, v[i][2], up, rsurface_array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
2681                         }
2682                         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);
2683                         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);
2684                 }
2685                 rsurface_vertex3f = rsurface_array_deformedvertex3f;
2686                 rsurface_svector3f = rsurface_array_deformedsvector3f;
2687                 rsurface_tvector3f = rsurface_array_deformedtvector3f;
2688                 rsurface_normal3f = rsurface_array_deformednormal3f;
2689         }
2690         R_Mesh_VertexPointer(rsurface_vertex3f);
2691 }
2692
2693 void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacelist)
2694 {
2695         int texturesurfaceindex;
2696         const msurface_t *surface = texturesurfacelist[0];
2697         int firstvertex = surface->num_firstvertex;
2698         int endvertex = surface->num_firstvertex + surface->num_vertices;
2699         if (texturenumsurfaces == 1)
2700         {
2701                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2702                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
2703         }
2704         else if (r_batchmode.integer == 2)
2705         {
2706                 #define MAXBATCHTRIANGLES 4096
2707                 int batchtriangles = 0;
2708                 int batchelements[MAXBATCHTRIANGLES*3];
2709                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2710                 {
2711                         surface = texturesurfacelist[texturesurfaceindex];
2712                         if (surface->num_triangles >= 256 || (batchtriangles == 0 && texturesurfaceindex + 1 >= texturenumsurfaces))
2713                         {
2714                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
2715                                 continue;
2716                         }
2717                         if (batchtriangles + surface->num_triangles > MAXBATCHTRIANGLES)
2718                         {
2719                                 R_Mesh_Draw(firstvertex, endvertex - firstvertex, batchtriangles, batchelements);
2720                                 batchtriangles = 0;
2721                                 firstvertex = surface->num_firstvertex;
2722                                 endvertex = surface->num_firstvertex + surface->num_vertices;
2723                         }
2724                         else
2725                         {
2726                                 firstvertex = min(firstvertex, surface->num_firstvertex);
2727                                 endvertex = max(endvertex, surface->num_firstvertex + surface->num_vertices);
2728                         }
2729                         memcpy(batchelements + batchtriangles * 3, rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
2730                         batchtriangles += surface->num_triangles;
2731                 }
2732                 if (batchtriangles)
2733                         R_Mesh_Draw(firstvertex, endvertex - firstvertex, batchtriangles, batchelements);
2734         }
2735         else if (r_batchmode.integer == 1)
2736         {
2737                 int firsttriangle = 0;
2738                 int endtriangle = -1;
2739                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2740                 {
2741                         surface = texturesurfacelist[texturesurfaceindex];
2742                         if (surface->num_firsttriangle != endtriangle)
2743                         {
2744                                 if (endtriangle > firsttriangle)
2745                                 {
2746                                         GL_LockArrays(firstvertex, endvertex - firstvertex);
2747                                         R_Mesh_Draw(firstvertex, endvertex - firstvertex, endtriangle - firsttriangle, (rsurface_model->surfmesh.data_element3i + 3 * firsttriangle));
2748                                 }
2749                                 firstvertex = surface->num_firstvertex;
2750                                 endvertex = surface->num_firstvertex + surface->num_vertices;
2751                                 firsttriangle = surface->num_firsttriangle;
2752                         }
2753                         else
2754                         {
2755                                 firstvertex = min(firstvertex, surface->num_firstvertex);
2756                                 endvertex = max(endvertex, surface->num_firstvertex + surface->num_vertices);
2757                         }
2758                         endtriangle = surface->num_firsttriangle + surface->num_triangles;
2759                 }
2760                 if (endtriangle > firsttriangle)
2761                 {
2762                         GL_LockArrays(firstvertex, endvertex - firstvertex);
2763                         R_Mesh_Draw(firstvertex, endvertex - firstvertex, endtriangle - firsttriangle, (rsurface_model->surfmesh.data_element3i + 3 * firsttriangle));
2764                 }
2765         }
2766         else
2767         {
2768                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2769                 {
2770                         surface = texturesurfacelist[texturesurfaceindex];
2771                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2772                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
2773                 }
2774         }
2775 }
2776
2777 static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
2778 {
2779         int texturesurfaceindex;
2780         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2781         {
2782                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2783                 int k = (int)(((size_t)surface) / sizeof(msurface_t));
2784                 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);
2785                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2786                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
2787         }
2788 }
2789
2790 static void RSurf_DrawBatch_Lightmap(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, int lightmode, qboolean applycolor, qboolean applyfog)
2791 {
2792         int texturesurfaceindex;
2793         int i;
2794         float f;
2795         float *v, *c, *c2;
2796         // TODO: optimize
2797         if (lightmode >= 2)
2798         {
2799                 // model lighting
2800                 vec3_t ambientcolor;
2801                 vec3_t diffusecolor;
2802                 vec3_t lightdir;
2803                 VectorCopy(rsurface_entity->modellight_lightdir, lightdir);
2804                 ambientcolor[0] = rsurface_entity->modellight_ambient[0] * r * 0.5f;
2805                 ambientcolor[1] = rsurface_entity->modellight_ambient[1] * g * 0.5f;
2806                 ambientcolor[2] = rsurface_entity->modellight_ambient[2] * b * 0.5f;
2807                 diffusecolor[0] = rsurface_entity->modellight_diffuse[0] * r * 0.5f;
2808                 diffusecolor[1] = rsurface_entity->modellight_diffuse[1] * g * 0.5f;
2809                 diffusecolor[2] = rsurface_entity->modellight_diffuse[2] * b * 0.5f;
2810                 if (VectorLength2(diffusecolor) > 0)
2811                 {
2812                         // generate color arrays for the surfaces in this list
2813                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2814                         {
2815                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2816                                 int numverts = surface->num_vertices;
2817                                 v = rsurface_vertex3f + 3 * surface->num_firstvertex;
2818                                 c2 = rsurface_normal3f + 3 * surface->num_firstvertex;
2819                                 c = rsurface_array_color4f + 4 * surface->num_firstvertex;
2820                                 // q3-style directional shading
2821                                 for (i = 0;i < numverts;i++, v += 3, c2 += 3, c += 4)
2822                                 {
2823                                         if ((f = DotProduct(c2, lightdir)) > 0)
2824                                                 VectorMA(ambientcolor, f, diffusecolor, c);
2825                                         else
2826                                                 VectorCopy(ambientcolor, c);
2827                                         c[3] = a;
2828                                 }
2829                         }
2830                         r = 1;
2831                         g = 1;
2832                         b = 1;
2833                         a = 1;
2834                         applycolor = false;
2835                         rsurface_lightmapcolor4f = rsurface_array_color4f;
2836                 }
2837                 else
2838                 {
2839                         r = ambientcolor[0];
2840                         g = ambientcolor[1];
2841                         b = ambientcolor[2];
2842                         rsurface_lightmapcolor4f = NULL;
2843                 }
2844         }
2845         else if (lightmode >= 1 || !rsurface_lightmaptexture)
2846         {
2847                 if (texturesurfacelist[0]->lightmapinfo && texturesurfacelist[0]->lightmapinfo->stainsamples)
2848                 {
2849                         // generate color arrays for the surfaces in this list
2850                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2851                         {
2852                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2853                                 for (i = 0, c = rsurface_array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
2854                                 {
2855                                         if (surface->lightmapinfo->samples)
2856                                         {
2857                                                 const unsigned char *lm = surface->lightmapinfo->samples + (rsurface_model->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i];
2858                                                 float scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
2859                                                 VectorScale(lm, scale, c);
2860                                                 if (surface->lightmapinfo->styles[1] != 255)
2861                                                 {
2862                                                         int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
2863                                                         lm += size3;
2864                                                         scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
2865                                                         VectorMA(c, scale, lm, c);
2866                                                         if (surface->lightmapinfo->styles[2] != 255)
2867                                                         {
2868                                                                 lm += size3;
2869                                                                 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
2870                                                                 VectorMA(c, scale, lm, c);
2871                                                                 if (surface->lightmapinfo->styles[3] != 255)
2872                                                                 {
2873                                                                         lm += size3;
2874                                                                         scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
2875                                                                         VectorMA(c, scale, lm, c);
2876                                                                 }
2877                                                         }
2878                                                 }
2879                                         }
2880                                         else
2881                                                 VectorClear(c);
2882                                         c[3] = 1;
2883                                 }
2884                         }
2885                         rsurface_lightmapcolor4f = rsurface_array_color4f;
2886                 }
2887                 else
2888                         rsurface_lightmapcolor4f = rsurface_model->surfmesh.data_lightmapcolor4f;
2889         }
2890         else
2891         {
2892                 // just lightmap it
2893                 rsurface_lightmapcolor4f = NULL;
2894         }
2895         if (applyfog)
2896         {
2897                 if (rsurface_lightmapcolor4f)
2898                 {
2899                         // generate color arrays for the surfaces in this list
2900                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2901                         {
2902                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2903                                 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)
2904                                 {
2905                                         f = 1 - VERTEXFOGTABLE(VectorDistance(v, rsurface_modelorg));
2906                                         c2[0] = c[0] * f;
2907                                         c2[1] = c[1] * f;
2908                                         c2[2] = c[2] * f;
2909                                         c2[3] = c[3];
2910                                 }
2911                         }
2912                 }
2913                 else
2914                 {
2915                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2916                         {
2917                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2918                                 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)
2919                                 {
2920                                         f = 1 - VERTEXFOGTABLE(VectorDistance(v, rsurface_modelorg));
2921                                         c2[0] = f;
2922                                         c2[1] = f;
2923                                         c2[2] = f;
2924                                         c2[3] = 1;
2925                                 }
2926                         }
2927                 }
2928                 rsurface_lightmapcolor4f = rsurface_array_color4f;
2929         }
2930         if (applycolor && rsurface_lightmapcolor4f)
2931         {
2932                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2933                 {
2934                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
2935                         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)
2936                         {
2937                                 c2[0] = c[0] * r;
2938                                 c2[1] = c[1] * g;
2939                                 c2[2] = c[2] * b;
2940                                 c2[3] = c[3] * a;
2941                         }
2942                 }
2943                 rsurface_lightmapcolor4f = rsurface_array_color4f;
2944         }
2945         R_Mesh_ColorPointer(rsurface_lightmapcolor4f);
2946         GL_Color(r, g, b, a);
2947         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
2948 }
2949
2950 static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
2951 {
2952         if (rsurface_mode != RSURFMODE_SHOWSURFACES)
2953         {
2954                 rsurface_mode = RSURFMODE_SHOWSURFACES;
2955                 GL_DepthMask(true);
2956                 GL_BlendFunc(GL_ONE, GL_ZERO);
2957                 R_Mesh_ColorPointer(NULL);
2958                 R_Mesh_ResetTextureState();
2959         }
2960         RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
2961         RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
2962 }
2963
2964 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, msurface_t **texturesurfacelist)
2965 {
2966         // transparent sky would be ridiculous
2967         if ((rsurface_texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT))
2968                 return;
2969         if (rsurface_mode != RSURFMODE_SKY)
2970         {
2971                 if (rsurface_mode == RSURFMODE_GLSL)
2972                 {
2973                         qglUseProgramObjectARB(0);CHECKGLERROR
2974                 }
2975                 rsurface_mode = RSURFMODE_SKY;
2976         }
2977         if (skyrendernow)
2978         {
2979                 skyrendernow = false;
2980                 R_Sky();
2981                 // restore entity matrix
2982                 R_Mesh_Matrix(&rsurface_entity->matrix);
2983         }
2984         GL_DepthMask(true);
2985         // LordHavoc: HalfLife maps have freaky skypolys so don't use
2986         // skymasking on them, and Quake3 never did sky masking (unlike
2987         // software Quake and software Quake2), so disable the sky masking
2988         // in Quake3 maps as it causes problems with q3map2 sky tricks,
2989         // and skymasking also looks very bad when noclipping outside the
2990         // level, so don't use it then either.
2991         if (rsurface_model->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_viewcache.world_novis)
2992         {
2993                 GL_Color(r_refdef.fogcolor[0] * r_view.colorscale, r_refdef.fogcolor[1] * r_view.colorscale, r_refdef.fogcolor[2] * r_view.colorscale, 1);
2994                 R_Mesh_ColorPointer(NULL);
2995                 R_Mesh_ResetTextureState();
2996                 if (skyrendermasked)
2997                 {
2998                         // depth-only (masking)
2999                         GL_ColorMask(0,0,0,0);
3000                         // just to make sure that braindead drivers don't draw
3001                         // anything despite that colormask...
3002                         GL_BlendFunc(GL_ZERO, GL_ONE);
3003                 }
3004                 else
3005                 {
3006                         // fog sky
3007                         GL_BlendFunc(GL_ONE, GL_ZERO);
3008                 }
3009                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
3010                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
3011                 if (skyrendermasked)
3012                         GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
3013         }
3014 }
3015
3016 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, msurface_t **texturesurfacelist)
3017 {
3018         int lightmode;
3019         // FIXME: identify models using a better check than rsurface_model->brush.shadowmesh
3020         lightmode = ((rsurface_entity->effects & EF_FULLBRIGHT) || rsurface_model->brush.shadowmesh) ? 0 : 2;
3021         if (rsurface_mode != RSURFMODE_GLSL)
3022         {
3023                 rsurface_mode = RSURFMODE_GLSL;
3024                 rsurface_glsl_texture = NULL;
3025                 rsurface_glsl_uselightmap = false;
3026                 R_Mesh_ResetTextureState();
3027         }
3028         if (rsurface_glsl_texture != rsurface_texture || rsurface_glsl_uselightmap != (rsurface_lightmaptexture != NULL))
3029         {
3030                 rsurface_glsl_texture = rsurface_texture;
3031                 rsurface_glsl_uselightmap = rsurface_lightmaptexture != NULL;
3032                 GL_BlendFunc(rsurface_texture->currentlayers[0].blendfunc1, rsurface_texture->currentlayers[0].blendfunc2);
3033                 GL_DepthMask(!(rsurface_texture->currentmaterialflags & MATERIALFLAG_BLENDED));
3034                 GL_Color(rsurface_entity->colormod[0], rsurface_entity->colormod[1], rsurface_entity->colormod[2], rsurface_texture->currentalpha);
3035                 R_SetupSurfaceShader(vec3_origin, lightmode == 2);
3036                 //permutation_deluxemapping = permutation_lightmapping = R_SetupSurfaceShader(vec3_origin, lightmode == 2, false);
3037                 //if (r_glsl_deluxemapping.integer)
3038                 //      permutation_deluxemapping = R_SetupSurfaceShader(vec3_origin, lightmode == 2, true);
3039                 R_Mesh_TexCoordPointer(0, 2, rsurface_model->surfmesh.data_texcoordtexture2f);
3040                 R_Mesh_TexCoordPointer(4, 2, rsurface_model->surfmesh.data_texcoordlightmap2f);
3041                 GL_AlphaTest((rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
3042         }
3043         if (!r_glsl_permutation)
3044                 return;
3045         RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
3046         R_Mesh_TexCoordPointer(1, 3, rsurface_svector3f);
3047         R_Mesh_TexCoordPointer(2, 3, rsurface_tvector3f);
3048         R_Mesh_TexCoordPointer(3, 3, rsurface_normal3f);
3049         if (rsurface_texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
3050         {
3051                 R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
3052                 if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
3053                         R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
3054                 R_Mesh_ColorPointer(NULL);
3055         }
3056         else if (rsurface_lightmaptexture)
3057         {
3058                 R_Mesh_TexBind(7, R_GetTexture(rsurface_lightmaptexture));
3059                 if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
3060                         R_Mesh_TexBind(8, R_GetTexture(texturesurfacelist[0]->deluxemaptexture));
3061                 R_Mesh_ColorPointer(NULL);
3062         }
3063         else
3064         {
3065                 R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
3066                 if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
3067                         R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
3068                 R_Mesh_ColorPointer(rsurface_model->surfmesh.data_lightmapcolor4f);
3069         }
3070         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
3071 }
3072
3073 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **texturesurfacelist)
3074 {
3075         // OpenGL 1.3 path - anything not completely ancient
3076         int texturesurfaceindex;
3077         int lightmode;
3078         qboolean applycolor;
3079         qboolean applyfog;
3080         rmeshstate_t m;
3081         int layerindex;
3082         const texturelayer_t *layer;
3083         CHECKGLERROR
3084         // FIXME: identify models using a better check than rsurface_model->brush.shadowmesh
3085         lightmode = ((rsurface_entity->effects & EF_FULLBRIGHT) || rsurface_model->brush.shadowmesh) ? 0 : 2;
3086         if (rsurface_mode != RSURFMODE_MULTIPASS)
3087                 rsurface_mode = RSURFMODE_MULTIPASS;
3088         RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
3089         for (layerindex = 0, layer = rsurface_texture->currentlayers;layerindex < rsurface_texture->currentnumlayers;layerindex++, layer++)
3090         {
3091                 vec4_t layercolor;
3092                 int layertexrgbscale;
3093                 if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
3094                 {
3095                         if (layerindex == 0)
3096                                 GL_AlphaTest(true);
3097                         else
3098                         {
3099                                 GL_AlphaTest(false);
3100                                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
3101                         }
3102                 }
3103                 GL_DepthMask(layer->depthmask);
3104                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
3105                 if ((layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2) && (gl_combine.integer || layer->depthmask))
3106                 {
3107                         layertexrgbscale = 4;
3108                         VectorScale(layer->color, 0.25f, layercolor);
3109                 }
3110                 else if ((layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1) && (gl_combine.integer || layer->depthmask))
3111                 {
3112                         layertexrgbscale = 2;
3113                         VectorScale(layer->color, 0.5f, layercolor);
3114                 }
3115                 else
3116                 {
3117                         layertexrgbscale = 1;
3118                         VectorScale(layer->color, 1.0f, layercolor);
3119                 }
3120                 layercolor[3] = layer->color[3];
3121                 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
3122                 R_Mesh_ColorPointer(NULL);
3123                 applyfog = (layer->flags & TEXTURELAYERFLAG_FOGDARKEN) != 0;
3124                 switch (layer->type)
3125                 {
3126                 case TEXTURELAYERTYPE_LITTEXTURE:
3127                         memset(&m, 0, sizeof(m));
3128                         if (lightmode >= 1 || !rsurface_lightmaptexture)
3129                                 m.tex[0] = R_GetTexture(r_texture_white);
3130                         else
3131                                 m.tex[0] = R_GetTexture(rsurface_lightmaptexture);
3132                         m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordlightmap2f;
3133                         m.tex[1] = R_GetTexture(layer->texture);
3134                         m.texmatrix[1] = layer->texmatrix;
3135                         m.texrgbscale[1] = layertexrgbscale;
3136                         m.pointer_texcoord[1] = rsurface_model->surfmesh.data_texcoordtexture2f;
3137                         R_Mesh_TextureState(&m);
3138                         RSurf_DrawBatch_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], lightmode, applycolor, applyfog);
3139                         break;
3140                 case TEXTURELAYERTYPE_TEXTURE:
3141                         memset(&m, 0, sizeof(m));
3142                         m.tex[0] = R_GetTexture(layer->texture);
3143                         m.texmatrix[0] = layer->texmatrix;
3144                         m.texrgbscale[0] = layertexrgbscale;
3145                         m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
3146                         R_Mesh_TextureState(&m);
3147                         RSurf_DrawBatch_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], 0, applycolor, applyfog);
3148                         break;
3149                 case TEXTURELAYERTYPE_FOG:
3150                         memset(&m, 0, sizeof(m));
3151                         m.texrgbscale[0] = layertexrgbscale;
3152                         if (layer->texture)
3153                         {
3154                                 m.tex[0] = R_GetTexture(layer->texture);
3155                                 m.texmatrix[0] = layer->texmatrix;
3156                                 m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
3157                         }
3158                         R_Mesh_TextureState(&m);
3159                         // generate a color array for the fog pass
3160                         R_Mesh_ColorPointer(rsurface_array_color4f);
3161                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
3162                         {
3163                                 int i;
3164                                 float f, *v, *c;
3165                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
3166                                 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)
3167                                 {
3168                                         f = VERTEXFOGTABLE(VectorDistance(v, rsurface_modelorg));
3169                                         c[0] = layercolor[0];
3170                                         c[1] = layercolor[1];
3171                                         c[2] = layercolor[2];
3172                                         c[3] = f * layercolor[3];
3173                                 }
3174                         }
3175                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
3176                         break;
3177                 default:
3178                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
3179                 }
3180                 GL_LockArrays(0, 0);
3181         }
3182         CHECKGLERROR
3183         if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
3184         {
3185                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
3186                 GL_AlphaTest(false);
3187         }
3188 }
3189
3190 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **texturesurfacelist)
3191 {
3192         // OpenGL 1.1 - crusty old voodoo path
3193         int texturesurfaceindex;
3194         int lightmode;
3195         qboolean applyfog;
3196         rmeshstate_t m;
3197         int layerindex;
3198         const texturelayer_t *layer;
3199         CHECKGLERROR
3200         // FIXME: identify models using a better check than rsurface_model->brush.shadowmesh
3201         lightmode = ((rsurface_entity->effects & EF_FULLBRIGHT) || rsurface_model->brush.shadowmesh) ? 0 : 2;
3202         if (rsurface_mode != RSURFMODE_MULTIPASS)
3203                 rsurface_mode = RSURFMODE_MULTIPASS;
3204         RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
3205         for (layerindex = 0, layer = rsurface_texture->currentlayers;layerindex < rsurface_texture->currentnumlayers;layerindex++, layer++)
3206         {
3207                 if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
3208                 {
3209                         if (layerindex == 0)
3210                                 GL_AlphaTest(true);
3211                         else
3212                         {
3213                                 GL_AlphaTest(false);
3214                                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
3215                         }
3216                 }
3217                 GL_DepthMask(layer->depthmask);
3218                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
3219                 R_Mesh_ColorPointer(NULL);
3220                 applyfog = (layer->flags & TEXTURELAYERFLAG_FOGDARKEN) != 0;
3221                 switch (layer->type)
3222                 {
3223                 case TEXTURELAYERTYPE_LITTEXTURE:
3224                         if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
3225                         {
3226                                 // two-pass lit texture with 2x rgbscale
3227                                 // first the lightmap pass
3228                                 memset(&m, 0, sizeof(m));
3229                                 if (lightmode >= 1 || !rsurface_lightmaptexture)
3230                                         m.tex[0] = R_GetTexture(r_texture_white);
3231                                 else
3232                                         m.tex[0] = R_GetTexture(rsurface_lightmaptexture);
3233                                 m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordlightmap2f;
3234                                 R_Mesh_TextureState(&m);
3235                                 RSurf_DrawBatch_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, lightmode, false, false);
3236                                 GL_LockArrays(0, 0);
3237                                 // then apply the texture to it
3238                                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
3239                                 memset(&m, 0, sizeof(m));
3240                                 m.tex[0] = R_GetTexture(layer->texture);
3241                                 m.texmatrix[0] = layer->texmatrix;
3242                                 m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
3243                                 R_Mesh_TextureState(&m);
3244                                 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);
3245                         }
3246                         else
3247                         {
3248                                 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
3249                                 memset(&m, 0, sizeof(m));
3250                                 m.tex[0] = R_GetTexture(layer->texture);
3251                                 m.texmatrix[0] = layer->texmatrix;
3252                                 m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
3253                                 R_Mesh_TextureState(&m);
3254                                 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);
3255                         }
3256                         break;
3257                 case TEXTURELAYERTYPE_TEXTURE:
3258                         // singletexture unlit texture with transparency support
3259                         memset(&m, 0, sizeof(m));
3260                         m.tex[0] = R_GetTexture(layer->texture);
3261                         m.texmatrix[0] = layer->texmatrix;
3262                         m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
3263                         R_Mesh_TextureState(&m);
3264                         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);
3265                         break;
3266                 case TEXTURELAYERTYPE_FOG:
3267                         // singletexture fogging
3268                         R_Mesh_ColorPointer(rsurface_array_color4f);
3269                         if (layer->texture)
3270                         {
3271                                 memset(&m, 0, sizeof(m));
3272                                 m.tex[0] = R_GetTexture(layer->texture);
3273                                 m.texmatrix[0] = layer->texmatrix;
3274                                 m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
3275                                 R_Mesh_TextureState(&m);
3276                         }
3277                         else
3278                                 R_Mesh_ResetTextureState();
3279                         // generate a color array for the fog pass
3280                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
3281                         {
3282                                 int i;
3283                                 float f, *v, *c;
3284                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
3285                                 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)
3286                                 {
3287                                         f = VERTEXFOGTABLE(VectorDistance(v, rsurface_modelorg));
3288                                         c[0] = layer->color[0];
3289                                         c[1] = layer->color[1];
3290                                         c[2] = layer->color[2];
3291                                         c[3] = f * layer->color[3];
3292                                 }
3293                         }
3294                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
3295                         break;
3296                 default:
3297                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
3298                 }
3299                 GL_LockArrays(0, 0);
3300         }
3301         CHECKGLERROR
3302         if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
3303         {
3304                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
3305                 GL_AlphaTest(false);
3306         }
3307 }
3308
3309 static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **texturesurfacelist)
3310 {
3311         if (rsurface_texture->currentmaterialflags & MATERIALFLAG_NODRAW)
3312                 return;
3313         r_shadow_rtlight = NULL;
3314         r_refdef.stats.entities_surfaces += texturenumsurfaces;
3315         CHECKGLERROR
3316         GL_DepthTest(!(rsurface_texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
3317         GL_CullFace(((rsurface_texture->textureflags & Q3TEXTUREFLAG_TWOSIDED) || (rsurface_entity->flags & RENDER_NOCULLFACE)) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces
3318         if (r_showsurfaces.integer)
3319                 R_DrawTextureSurfaceList_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
3320         else if (rsurface_texture->currentmaterialflags & MATERIALFLAG_SKY)
3321                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
3322         else if (rsurface_texture->currentnumlayers)
3323         {
3324                 if (r_glsl.integer && gl_support_fragment_shader)
3325                         R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist);
3326                 else if (gl_combine.integer && r_textureunits.integer >= 2)
3327                         R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist);
3328                 else
3329                         R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist);
3330         }
3331         CHECKGLERROR
3332         GL_LockArrays(0, 0);
3333 }
3334
3335 #define BATCHSIZE 256
3336 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
3337 {
3338         int surfacelistindex;
3339         int batchcount;
3340         texture_t *t;
3341         msurface_t *texturesurfacelist[BATCHSIZE];
3342         // if the model is static it doesn't matter what value we give for
3343         // wantnormals and wanttangents, so this logic uses only rules applicable
3344         // to a model, knowing that they are meaningless otherwise
3345         if ((ent->effects & EF_FULLBRIGHT) || r_showsurfaces.integer || VectorLength2(ent->modellight_diffuse) < (1.0f / 256.0f))
3346                 RSurf_ActiveEntity(ent, false, false);
3347         else
3348                 RSurf_ActiveEntity(ent, true, r_glsl.integer && gl_support_fragment_shader);
3349         batchcount = 0;
3350         t = NULL;
3351         for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
3352         {
3353                 msurface_t *surface = ent->model->data_surfaces + surfacelist[surfacelistindex];
3354
3355                 if (t != surface->texture || rsurface_lightmaptexture != surface->lightmaptexture)
3356                 {
3357                         if (batchcount > 0)
3358                                 R_DrawTextureSurfaceList(batchcount, texturesurfacelist);
3359                         batchcount = 0;
3360                         t = surface->texture;
3361                         rsurface_lightmaptexture = surface->lightmaptexture;
3362                         R_UpdateTextureInfo(ent, t);
3363                         rsurface_texture = t->currentframe;
3364                 }
3365                 if (rsurface_texture->currentmaterialflags & MATERIALFLAG_SKY)
3366                         continue; // transparent sky is too difficult
3367
3368                 texturesurfacelist[batchcount++] = surface;
3369         }
3370         if (batchcount > 0)
3371                 R_DrawTextureSurfaceList(batchcount, texturesurfacelist);
3372         RSurf_CleanUp();
3373 }
3374
3375 void R_QueueTextureSurfaceList(int texturenumsurfaces, msurface_t **texturesurfacelist)
3376 {
3377         int texturesurfaceindex;
3378         vec3_t tempcenter, center;
3379         if (rsurface_texture->currentmaterialflags & MATERIALFLAG_BLENDED)
3380         {
3381                 // drawing sky transparently would be too difficult
3382                 if (!(rsurface_texture->currentmaterialflags & MATERIALFLAG_SKY))
3383                 {
3384                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
3385                         {
3386                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
3387                                 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
3388                                 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
3389                                 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
3390                                 Matrix4x4_Transform(&rsurface_entity->matrix, tempcenter, center);
3391                                 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);
3392                         }
3393                 }
3394         }
3395         else
3396                 R_DrawTextureSurfaceList(texturenumsurfaces, texturesurfacelist);
3397 }
3398
3399 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
3400 void R_DrawSurfaces(entity_render_t *ent, qboolean skysurfaces)
3401 {
3402         int i, j, f, flagsmask;
3403         int counttriangles = 0;
3404         texture_t *t;
3405         model_t *model = ent->model;
3406         const int maxsurfacelist = 1024;
3407         int numsurfacelist = 0;
3408         msurface_t *surfacelist[1024];
3409         if (model == NULL)
3410                 return;
3411
3412         // if the model is static it doesn't matter what value we give for
3413         // wantnormals and wanttangents, so this logic uses only rules applicable
3414         // to a model, knowing that they are meaningless otherwise
3415         if ((ent->effects & EF_FULLBRIGHT) || r_showsurfaces.integer || VectorLength2(ent->modellight_diffuse) < (1.0f / 256.0f))
3416                 RSurf_ActiveEntity(ent, false, false);
3417         else
3418                 RSurf_ActiveEntity(ent, true, r_glsl.integer && gl_support_fragment_shader);
3419
3420         // update light styles
3421         if (!skysurfaces && model->brushq1.light_styleupdatechains)
3422         {
3423                 msurface_t *surface, **surfacechain;
3424                 for (i = 0;i < model->brushq1.light_styles;i++)
3425                 {
3426                         if (model->brushq1.light_stylevalue[i] != r_refdef.lightstylevalue[model->brushq1.light_style[i]])
3427                         {
3428                                 model->brushq1.light_stylevalue[i] = r_refdef.lightstylevalue[model->brushq1.light_style[i]];
3429                                 if ((surfacechain = model->brushq1.light_styleupdatechains[i]))
3430                                         for (;(surface = *surfacechain);surfacechain++)
3431                                                 surface->cached_dlight = true;
3432                         }
3433                 }
3434         }
3435
3436         R_UpdateAllTextureInfo(ent);
3437         flagsmask = skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL);
3438         f = 0;
3439         t = NULL;
3440         rsurface_lightmaptexture = NULL;
3441         rsurface_texture = NULL;
3442         numsurfacelist = 0;
3443         if (ent == r_refdef.worldentity)
3444         {
3445                 msurface_t *surface;
3446                 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
3447                 {
3448                         if (!r_viewcache.world_surfacevisible[j])
3449                                 continue;
3450                         if (t != surface->texture || rsurface_lightmaptexture != surface->lightmaptexture)
3451                         {
3452                                 if (numsurfacelist)
3453                                 {
3454                                         R_QueueTextureSurfaceList(numsurfacelist, surfacelist);
3455                                         numsurfacelist = 0;
3456                                 }
3457                                 t = surface->texture;
3458                                 rsurface_lightmaptexture = surface->lightmaptexture;
3459                                 rsurface_texture = t->currentframe;
3460                                 f = rsurface_texture->currentmaterialflags & flagsmask;
3461                         }
3462                         if (f && surface->num_triangles)
3463                         {
3464                                 // if lightmap parameters changed, rebuild lightmap texture
3465                                 if (surface->cached_dlight)
3466                                         R_BuildLightMap(ent, surface);
3467                                 // add face to draw list
3468                                 surfacelist[numsurfacelist++] = surface;
3469                                 counttriangles += surface->num_triangles;
3470                                 if (numsurfacelist >= maxsurfacelist)
3471                                 {
3472                                         R_QueueTextureSurfaceList(numsurfacelist, surfacelist);
3473                                         numsurfacelist = 0;
3474                                 }
3475                         }
3476                 }
3477         }
3478         else
3479         {
3480                 msurface_t *surface;
3481                 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
3482                 {
3483                         if (t != surface->texture || rsurface_lightmaptexture != surface->lightmaptexture)
3484                         {
3485                                 if (numsurfacelist)
3486                                 {
3487                                         R_QueueTextureSurfaceList(numsurfacelist, surfacelist);
3488                                         numsurfacelist = 0;
3489                                 }
3490                                 t = surface->texture;
3491                                 rsurface_lightmaptexture = surface->lightmaptexture;
3492                                 rsurface_texture = t->currentframe;
3493                                 f = rsurface_texture->currentmaterialflags & flagsmask;
3494                         }
3495                         if (f && surface->num_triangles)
3496                         {
3497                                 // if lightmap parameters changed, rebuild lightmap texture
3498                                 if (surface->cached_dlight)
3499                                         R_BuildLightMap(ent, surface);
3500                                 // add face to draw list
3501                                 surfacelist[numsurfacelist++] = surface;
3502                                 counttriangles += surface->num_triangles;
3503                                 if (numsurfacelist >= maxsurfacelist)
3504                                 {
3505                                         R_QueueTextureSurfaceList(numsurfacelist, surfacelist);
3506                                         numsurfacelist = 0;
3507                                 }
3508                         }
3509                 }
3510         }
3511         if (numsurfacelist)
3512                 R_QueueTextureSurfaceList(numsurfacelist, surfacelist);
3513         r_refdef.stats.entities_triangles += counttriangles;
3514         RSurf_CleanUp();
3515
3516         if (r_showcollisionbrushes.integer && model->brush.num_brushes && !skysurfaces)
3517         {
3518                 int i;
3519                 const msurface_t *surface;
3520                 q3mbrush_t *brush;
3521                 CHECKGLERROR
3522                 R_Mesh_Matrix(&ent->matrix);
3523                 R_Mesh_ColorPointer(NULL);
3524                 R_Mesh_ResetTextureState();
3525                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
3526                 GL_DepthMask(false);
3527                 GL_DepthTest(!r_showdisabledepthtest.integer);
3528                 qglPolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);CHECKGLERROR
3529                 for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
3530                         if (brush->colbrushf && brush->colbrushf->numtriangles)
3531                                 R_DrawCollisionBrush(brush->colbrushf);
3532                 for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
3533                         if (surface->num_collisiontriangles)
3534                                 R_DrawCollisionSurface(ent, surface);
3535                 qglPolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
3536         }
3537
3538         if (r_showtris.integer || r_shownormals.integer)
3539         {
3540                 int k, l;
3541                 msurface_t *surface;
3542                 const int *elements;
3543                 vec3_t v;
3544                 CHECKGLERROR
3545                 GL_DepthTest(true);
3546                 GL_DepthMask(true);
3547                 if (r_showdisabledepthtest.integer)
3548                 {
3549                         qglDepthFunc(GL_ALWAYS);CHECKGLERROR
3550                 }
3551                 GL_BlendFunc(GL_ONE, GL_ZERO);
3552                 R_Mesh_ColorPointer(NULL);
3553                 R_Mesh_ResetTextureState();
3554                 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
3555                 {
3556                         if (ent == r_refdef.worldentity && !r_viewcache.world_surfacevisible[j])
3557                                 continue;
3558                         rsurface_texture = surface->texture->currentframe;
3559                         if ((rsurface_texture->currentmaterialflags & flagsmask) && surface->num_triangles)
3560                         {
3561                                 RSurf_PrepareVerticesForBatch(true, true, 1, &surface);
3562                                 if (r_showtris.integer)
3563                                 {
3564                                         if (!rsurface_texture->currentlayers->depthmask)
3565                                                 GL_Color(r_showtris.value * r_view.colorscale, 0, 0, 1);
3566                                         else if (ent == r_refdef.worldentity)
3567                                                 GL_Color(r_showtris.value * r_view.colorscale, r_showtris.value * r_view.colorscale, r_showtris.value * r_view.colorscale, 1);
3568                                         else
3569                                                 GL_Color(0, r_showtris.value * r_view.colorscale, 0, 1);
3570                                         elements = (ent->model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);
3571                                         CHECKGLERROR
3572                                         qglBegin(GL_LINES);
3573                                         for (k = 0;k < surface->num_triangles;k++, elements += 3)
3574                                         {
3575                                                 qglArrayElement(elements[0]);qglArrayElement(elements[1]);
3576                                                 qglArrayElement(elements[1]);qglArrayElement(elements[2]);
3577                                                 qglArrayElement(elements[2]);qglArrayElement(elements[0]);
3578                                         }
3579                                         qglEnd();
3580                                         CHECKGLERROR
3581                                 }
3582                                 if (r_shownormals.integer)
3583                                 {
3584                                         GL_Color(r_shownormals.value * r_view.colorscale, 0, 0, 1);
3585                                         qglBegin(GL_LINES);
3586                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
3587                                         {
3588                                                 VectorCopy(rsurface_vertex3f + l * 3, v);
3589                                                 qglVertex3f(v[0], v[1], v[2]);
3590                                                 VectorMA(v, 8, rsurface_svector3f + l * 3, v);
3591                                                 qglVertex3f(v[0], v[1], v[2]);
3592                                         }
3593                                         qglEnd();
3594                                         CHECKGLERROR
3595                                         GL_Color(0, 0, r_shownormals.value * r_view.colorscale, 1);
3596                                         qglBegin(GL_LINES);
3597                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
3598                                         {
3599                                                 VectorCopy(rsurface_vertex3f + l * 3, v);
3600                                                 qglVertex3f(v[0], v[1], v[2]);
3601                                                 VectorMA(v, 8, rsurface_tvector3f + l * 3, v);
3602                                                 qglVertex3f(v[0], v[1], v[2]);
3603                                         }
3604                                         qglEnd();
3605                                         CHECKGLERROR
3606                                         GL_Color(0, r_shownormals.value * r_view.colorscale, 0, 1);
3607                                         qglBegin(GL_LINES);
3608                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
3609                                         {
3610                                                 VectorCopy(rsurface_vertex3f + l * 3, v);
3611                                                 qglVertex3f(v[0], v[1], v[2]);
3612                                                 VectorMA(v, 8, rsurface_normal3f + l * 3, v);
3613                                                 qglVertex3f(v[0], v[1], v[2]);
3614                                         }
3615                                         qglEnd();
3616                                         CHECKGLERROR
3617                                 }
3618                         }
3619                 }
3620                 rsurface_texture = NULL;
3621                 if (r_showdisabledepthtest.integer)
3622                 {
3623                         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
3624                 }
3625         }
3626 }