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