gl_rmain.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20 // r_main.c
  21
  22 #include "quakedef.h"
  23 #include "cl_dyntexture.h"
  24 #include "r_shadow.h"
  25 #include "polygon.h"
  26 #include "image.h"
  27
  28 mempool_t *r_main_mempool;
  29 rtexturepool_t *r_main_texturepool;
  30
  31 //
  32 // screen size info
  33 //
  34 r_refdef_t r_refdef;
  35
  36 cvar_t r_depthfirst = {CVAR_SAVE, "r_depthfirst", "1", "renders a depth-only version of the scene before normal rendering begins to eliminate overdraw, values: 0 = off, 1 = world depth, 2 = world and model depth"};
  37 cvar_t r_nearclip = {0, "r_nearclip", "1", "distance from camera of nearclip plane" };
  38 cvar_t r_showbboxes = {0, "r_showbboxes", "0", "shows bounding boxes of server entities, value controls opacity scaling (1 = 10%,  10 = 100%)"};
  39 cvar_t r_showsurfaces = {0, "r_showsurfaces", "0", "1 shows surfaces as different colors, or a value of 2 shows triangle draw order (for analyzing whether meshes are optimized for vertex cache)"};
  40 cvar_t r_showtris = {0, "r_showtris", "0", "shows triangle outlines, value controls brightness (can be above 1)"};
  41 cvar_t r_shownormals = {0, "r_shownormals", "0", "shows per-vertex surface normals and tangent vectors for bumpmapped lighting"};
  42 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"};
  43 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"};
  44 cvar_t r_showcollisionbrushes = {0, "r_showcollisionbrushes", "0", "draws collision brushes in quake3 maps (mode 1), mode 2 disables rendering of world (trippy!)"};
  45 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"};
  46 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"};
  47 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"};
  48 cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating polygons) in world interior in quake1 maps"};
  49 cvar_t r_drawentities = {0, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"};
  50 cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1", "draw your weapon model"};
  51 cvar_t r_cullentities_trace = {0, "r_cullentities_trace", "1", "probabistically cull invisible entities"};
  52 cvar_t r_cullentities_trace_samples = {0, "r_cullentities_trace_samples", "2", "number of samples to test for entity culling"};
  53 cvar_t r_cullentities_trace_enlarge = {0, "r_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
  54 cvar_t r_cullentities_trace_delay = {0, "r_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
  55 cvar_t r_speeds = {0, "r_speeds","0", "displays rendering statistics and per-subsystem timings"};
  56 cvar_t r_fullbright = {0, "r_fullbright","0", "makes map very bright and renders faster"};
  57 cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1", "opacity of water polygons"};
  58 cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1", "enables dynamic lights (rocket glow and such)"};
  59 cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1", "enables glowing pixels in quake textures (changes need r_restart to take effect)"};
  60 cvar_t r_shadows = {CVAR_SAVE, "r_shadows", "0", "casts fake stencil shadows from models onto the world (rtlights are unaffected by this)"};
  61 cvar_t r_shadows_throwdistance = {CVAR_SAVE, "r_shadows_throwdistance", "500", "how far to cast shadows from models"};
  62 cvar_t r_q1bsp_skymasking = {0, "r_q1bsp_skymasking", "1", "allows sky polygons in quake1 maps to obscure other geometry"};
  63 cvar_t r_polygonoffset_submodel_factor = {0, "r_polygonoffset_submodel_factor", "0", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
  64 cvar_t r_polygonoffset_submodel_offset = {0, "r_polygonoffset_submodel_offset", "2", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
  65 cvar_t r_fog_exp2 = {0, "r_fog_exp2", "0", "uses GL_EXP2 fog (as in Nehahra) rather than realistic GL_EXP fog"};
  66
  67 cvar_t gl_fogenable = {0, "gl_fogenable", "0", "nehahra fog enable (for Nehahra compatibility only)"};
  68 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25", "nehahra fog density (recommend values below 0.1) (for Nehahra compatibility only)"};
  69 cvar_t gl_fogred = {0, "gl_fogred","0.3", "nehahra fog color red value (for Nehahra compatibility only)"};
  70 cvar_t gl_foggreen = {0, "gl_foggreen","0.3", "nehahra fog color green value (for Nehahra compatibility only)"};
  71 cvar_t gl_fogblue = {0, "gl_fogblue","0.3", "nehahra fog color blue value (for Nehahra compatibility only)"};
  72 cvar_t gl_fogstart = {0, "gl_fogstart", "0", "nehahra fog start distance (for Nehahra compatibility only)"};
  73 cvar_t gl_fogend = {0, "gl_fogend","0", "nehahra fog end distance (for Nehahra compatibility only)"};
  74 cvar_t gl_skyclip = {0, "gl_skyclip", "4608", "nehahra farclip distance - the real fog end (for Nehahra compatibility only)"};
  75
  76 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)"};
  77
  78 cvar_t r_glsl = {CVAR_SAVE, "r_glsl", "1", "enables use of OpenGL 2.0 pixel shaders for lighting"};
  79 cvar_t r_glsl_contrastboost = {CVAR_SAVE, "r_glsl_contrastboost", "1", "by how much to multiply the contrast in dark areas (1 is no change)"};
  80 cvar_t r_glsl_deluxemapping = {CVAR_SAVE, "r_glsl_deluxemapping", "1", "use per pixel lighting on deluxemap-compiled q3bsp maps (or a value of 2 forces deluxemap shading even without deluxemaps)"};
  81 cvar_t r_glsl_offsetmapping = {CVAR_SAVE, "r_glsl_offsetmapping", "0", "offset mapping effect (also known as parallax mapping or virtual displacement mapping)"};
  82 cvar_t r_glsl_offsetmapping_reliefmapping = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"};
  83 cvar_t r_glsl_offsetmapping_scale = {CVAR_SAVE, "r_glsl_offsetmapping_scale", "0.04", "how deep the offset mapping effect is"};
  84 cvar_t r_glsl_postprocess = {CVAR_SAVE, "r_glsl_postprocess", "0", "use a GLSL postprocessing shader"};
  85 cvar_t r_glsl_postprocess_contrastboost = {CVAR_SAVE, "r_glsl_postprocess_contrastboost", "1", "brightening effect (1 is no change, higher values brighten the view)"};
  86 cvar_t r_glsl_postprocess_gamma = {CVAR_SAVE, "r_glsl_postprocess_gamma", "1", "inverse gamma correction value, a brightness effect that does not affect white or black, and tends to make the image grey and dull"};
  87 cvar_t r_glsl_postprocess_uservec1 = {CVAR_SAVE, "r_glsl_postprocess_uservec1", "0 0 0 0", "a 4-component vector to pass as uservec1 to the postprocessing shader (only useful if default.glsl has been customized)"};
  88 cvar_t r_glsl_postprocess_uservec2 = {CVAR_SAVE, "r_glsl_postprocess_uservec2", "0 0 0 0", "a 4-component vector to pass as uservec2 to the postprocessing shader (only useful if default.glsl has been customized)"};
  89 cvar_t r_glsl_postprocess_uservec3 = {CVAR_SAVE, "r_glsl_postprocess_uservec3", "0 0 0 0", "a 4-component vector to pass as uservec3 to the postprocessing shader (only useful if default.glsl has been customized)"};
  90 cvar_t r_glsl_postprocess_uservec4 = {CVAR_SAVE, "r_glsl_postprocess_uservec4", "0 0 0 0", "a 4-component vector to pass as uservec4 to the postprocessing shader (only useful if default.glsl has been customized)"};
  91 cvar_t r_glsl_usegeneric = {CVAR_SAVE, "r_glsl_usegeneric", "1", "use shaders for rendering simple geometry (rather than conventional fixed-function rendering for this purpose)"};
  92
  93 cvar_t r_water = {CVAR_SAVE, "r_water", "0", "whether to use reflections and refraction on water surfaces (note: r_wateralpha must be set below 1)"};
  94 cvar_t r_water_clippingplanebias = {CVAR_SAVE, "r_water_clippingplanebias", "1", "a rather technical setting which avoids black pixels around water edges"};
  95 cvar_t r_water_resolutionmultiplier = {CVAR_SAVE, "r_water_resolutionmultiplier", "0.5", "multiplier for screen resolution when rendering refracted/reflected scenes, 1 is full quality, lower values are faster"};
  96 cvar_t r_water_refractdistort = {CVAR_SAVE, "r_water_refractdistort", "0.01", "how much water refractions shimmer"};
  97 cvar_t r_water_reflectdistort = {CVAR_SAVE, "r_water_reflectdistort", "0.01", "how much water reflections shimmer"};
  98
  99 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "1", "enables animation smoothing on sprites (requires r_lerpmodels 1)"};
 100 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"};
 101 cvar_t r_lerplightstyles = {CVAR_SAVE, "r_lerplightstyles", "0", "enable animation smoothing on flickering lights"};
 102 cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1", "makes water scroll around, value controls how much"};
 103
 104 cvar_t r_bloom = {CVAR_SAVE, "r_bloom", "0", "enables bloom effect (makes bright pixels affect neighboring pixels)"};
 105 cvar_t r_bloom_colorscale = {CVAR_SAVE, "r_bloom_colorscale", "1", "how bright the glow is"};
 106 cvar_t r_bloom_brighten = {CVAR_SAVE, "r_bloom_brighten", "2", "how bright the glow is, after subtract/power"};
 107 cvar_t r_bloom_blur = {CVAR_SAVE, "r_bloom_blur", "4", "how large the glow is"};
 108 cvar_t r_bloom_resolution = {CVAR_SAVE, "r_bloom_resolution", "320", "what resolution to perform the bloom effect at (independent of screen resolution)"};
 109 cvar_t r_bloom_colorexponent = {CVAR_SAVE, "r_bloom_colorexponent", "1", "how exagerated the glow is"};
 110 cvar_t r_bloom_colorsubtract = {CVAR_SAVE, "r_bloom_colorsubtract", "0.125", "reduces bloom colors by a certain amount"};
 111
 112 cvar_t r_hdr = {CVAR_SAVE, "r_hdr", "0", "enables High Dynamic Range bloom effect (higher quality version of r_bloom)"};
 113 cvar_t r_hdr_scenebrightness = {CVAR_SAVE, "r_hdr_scenebrightness", "1", "global rendering brightness"};
 114 cvar_t r_hdr_glowintensity = {CVAR_SAVE, "r_hdr_glowintensity", "1", "how bright light emitting textures should appear"};
 115 cvar_t r_hdr_range = {CVAR_SAVE, "r_hdr_range", "4", "how much dynamic range to render bloom with (equivilant to multiplying r_bloom_brighten by this value and dividing r_bloom_colorscale by this value)"};
 116
 117 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"};
 118
 119 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"};
 120
 121 cvar_t gl_lightmaps = {0, "gl_lightmaps", "0", "draws only lightmaps, no texture (for level designers)"};
 122
 123 cvar_t r_test = {0, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"};
 124 cvar_t r_batchmode = {0, "r_batchmode", "1", "selects method of rendering multiple surfaces with one driver call (values are 0, 1, 2, etc...)"};
 125 cvar_t r_track_sprites = {CVAR_SAVE, "r_track_sprites", "1", "track SPR_LABEL* sprites by putting them as indicator at the screen border to rotate to"};
 126 cvar_t r_track_sprites_flags = {CVAR_SAVE, "r_track_sprites_flags", "1", "1: Rotate sprites accodringly, 2: Make it a continuous rotation"};
 127 cvar_t r_track_sprites_scalew = {CVAR_SAVE, "r_track_sprites_scalew", "1", "width scaling of tracked sprites"};
 128 cvar_t r_track_sprites_scaleh = {CVAR_SAVE, "r_track_sprites_scaleh", "1", "height scaling of tracked sprites"};
 129
 130 extern qboolean v_flipped_state;
 131
 132 static struct r_bloomstate_s
 133 {
 134         qboolean enabled;
 135         qboolean hdr;
 136
 137         int bloomwidth, bloomheight;
 138
 139         int screentexturewidth, screentextureheight;
 140         rtexture_t *texture_screen;
 141
 142         int bloomtexturewidth, bloomtextureheight;
 143         rtexture_t *texture_bloom;
 144
 145         // arrays for rendering the screen passes
 146         float screentexcoord2f[8];
 147         float bloomtexcoord2f[8];
 148         float offsettexcoord2f[8];
 149 }
 150 r_bloomstate;
 151
 152 typedef struct r_waterstate_waterplane_s
 153 {
 154         rtexture_t *texture_refraction;
 155         rtexture_t *texture_reflection;
 156         mplane_t plane;
 157         int materialflags; // combined flags of all water surfaces on this plane
 158         unsigned char pvsbits[(32768+7)>>3]; // FIXME: buffer overflow on huge maps
 159         qboolean pvsvalid;
 160 }
 161 r_waterstate_waterplane_t;
 162
 163 #define MAX_WATERPLANES 16
 164
 165 static struct r_waterstate_s
 166 {
 167         qboolean enabled;
 168
 169         qboolean renderingscene; // true while rendering a refraction or reflection texture, disables water surfaces
 170
 171         int waterwidth, waterheight;
 172         int texturewidth, textureheight;
 173
 174         int maxwaterplanes; // same as MAX_WATERPLANES
 175         int numwaterplanes;
 176         r_waterstate_waterplane_t waterplanes[MAX_WATERPLANES];
 177
 178         float screenscale[2];
 179         float screencenter[2];
 180 }
 181 r_waterstate;
 182
 183 // shadow volume bsp struct with automatically growing nodes buffer
 184 svbsp_t r_svbsp;
 185
 186 rtexture_t *r_texture_blanknormalmap;
 187 rtexture_t *r_texture_white;
 188 rtexture_t *r_texture_grey128;
 189 rtexture_t *r_texture_black;
 190 rtexture_t *r_texture_notexture;
 191 rtexture_t *r_texture_whitecube;
 192 rtexture_t *r_texture_normalizationcube;
 193 rtexture_t *r_texture_fogattenuation;
 194 //rtexture_t *r_texture_fogintensity;
 195
 196 char r_qwskincache[MAX_SCOREBOARD][MAX_QPATH];
 197 skinframe_t *r_qwskincache_skinframe[MAX_SCOREBOARD];
 198
 199 // vertex coordinates for a quad that covers the screen exactly
 200 const static float r_screenvertex3f[12] =
 201 {
 202         0, 0, 0,
 203         1, 0, 0,
 204         1, 1, 0,
 205         0, 1, 0
 206 };
 207
 208 extern void R_DrawModelShadows(void);
 209
 210 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
 211 {
 212         int i;
 213         for (i = 0;i < verts;i++)
 214         {
 215                 out[0] = in[0] * r;
 216                 out[1] = in[1] * g;
 217                 out[2] = in[2] * b;
 218                 out[3] = in[3];
 219                 in += 4;
 220                 out += 4;
 221         }
 222 }
 223
 224 void R_FillColors(float *out, int verts, float r, float g, float b, float a)
 225 {
 226         int i;
 227         for (i = 0;i < verts;i++)
 228         {
 229                 out[0] = r;
 230                 out[1] = g;
 231                 out[2] = b;
 232                 out[3] = a;
 233                 out += 4;
 234         }
 235 }
 236
 237 // FIXME: move this to client?
 238 void FOG_clear(void)
 239 {
 240         if (gamemode == GAME_NEHAHRA)
 241         {
 242                 Cvar_Set("gl_fogenable", "0");
 243                 Cvar_Set("gl_fogdensity", "0.2");
 244                 Cvar_Set("gl_fogred", "0.3");
 245                 Cvar_Set("gl_foggreen", "0.3");
 246                 Cvar_Set("gl_fogblue", "0.3");
 247         }
 248         r_refdef.fog_density = 0;
 249         r_refdef.fog_red = 0;
 250         r_refdef.fog_green = 0;
 251         r_refdef.fog_blue = 0;
 252         r_refdef.fog_alpha = 1;
 253         r_refdef.fog_start = 0;
 254         r_refdef.fog_end = 0;
 255 }
 256
 257 float FogForDistance(vec_t dist)
 258 {
 259         unsigned int fogmasktableindex = (unsigned int)(dist * r_refdef.fogmasktabledistmultiplier);
 260         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
 261 }
 262
 263 float FogPoint_World(const vec3_t p)
 264 {
 265         return FogForDistance(VectorDistance((p), r_refdef.view.origin));
 266 }
 267
 268 float FogPoint_Model(const vec3_t p)
 269 {
 270         return FogForDistance(VectorDistance((p), rsurface.modelorg));
 271 }
 272
 273 static void R_BuildBlankTextures(void)
 274 {
 275         unsigned char data[4];
 276         data[2] = 128; // normal X
 277         data[1] = 128; // normal Y
 278         data[0] = 255; // normal Z
 279         data[3] = 128; // height
 280         r_texture_blanknormalmap = R_LoadTexture2D(r_main_texturepool, "blankbump", 1, 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_PERSISTENT, NULL);
 281         data[0] = 255;
 282         data[1] = 255;
 283         data[2] = 255;
 284         data[3] = 255;
 285         r_texture_white = R_LoadTexture2D(r_main_texturepool, "blankwhite", 1, 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_PERSISTENT, NULL);
 286         data[0] = 128;
 287         data[1] = 128;
 288         data[2] = 128;
 289         data[3] = 255;
 290         r_texture_grey128 = R_LoadTexture2D(r_main_texturepool, "blankgrey128", 1, 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_PERSISTENT, NULL);
 291         data[0] = 0;
 292         data[1] = 0;
 293         data[2] = 0;
 294         data[3] = 255;
 295         r_texture_black = R_LoadTexture2D(r_main_texturepool, "blankblack", 1, 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_PERSISTENT, NULL);
 296 }
 297
 298 static void R_BuildNoTexture(void)
 299 {
 300         int x, y;
 301         unsigned char pix[16][16][4];
 302         // this makes a light grey/dark grey checkerboard texture
 303         for (y = 0;y < 16;y++)
 304         {
 305                 for (x = 0;x < 16;x++)
 306                 {
 307                         if ((y < 8) ^ (x < 8))
 308                         {
 309                                 pix[y][x][0] = 128;
 310                                 pix[y][x][1] = 128;
 311                                 pix[y][x][2] = 128;
 312                                 pix[y][x][3] = 255;
 313                         }
 314                         else
 315                         {
 316                                 pix[y][x][0] = 64;
 317                                 pix[y][x][1] = 64;
 318                                 pix[y][x][2] = 64;
 319                                 pix[y][x][3] = 255;
 320                         }
 321                 }
 322         }
 323         r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_BGRA, TEXF_MIPMAP | TEXF_PERSISTENT, NULL);
 324 }
 325
 326 static void R_BuildWhiteCube(void)
 327 {
 328         unsigned char data[6*1*1*4];
 329         memset(data, 255, sizeof(data));
 330         r_texture_whitecube = R_LoadTextureCubeMap(r_main_texturepool, "whitecube", 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_PERSISTENT, NULL);
 331 }
 332
 333 static void R_BuildNormalizationCube(void)
 334 {
 335         int x, y, side;
 336         vec3_t v;
 337         vec_t s, t, intensity;
 338 #define NORMSIZE 64
 339         unsigned char data[6][NORMSIZE][NORMSIZE][4];
 340         for (side = 0;side < 6;side++)
 341         {
 342                 for (y = 0;y < NORMSIZE;y++)
 343                 {
 344                         for (x = 0;x < NORMSIZE;x++)
 345                         {
 346                                 s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
 347                                 t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
 348                                 switch(side)
 349                                 {
 350                                 default:
 351                                 case 0:
 352                                         v[0] = 1;
 353                                         v[1] = -t;
 354                                         v[2] = -s;
 355                                         break;
 356                                 case 1:
 357                                         v[0] = -1;
 358                                         v[1] = -t;
 359                                         v[2] = s;
 360                                         break;
 361                                 case 2:
 362                                         v[0] = s;
 363                                         v[1] = 1;
 364                                         v[2] = t;
 365                                         break;
 366                                 case 3:
 367                                         v[0] = s;
 368                                         v[1] = -1;
 369                                         v[2] = -t;
 370                                         break;
 371                                 case 4:
 372                                         v[0] = s;
 373                                         v[1] = -t;
 374                                         v[2] = 1;
 375                                         break;
 376                                 case 5:
 377                                         v[0] = -s;
 378                                         v[1] = -t;
 379                                         v[2] = -1;
 380                                         break;
 381                                 }
 382                                 intensity = 127.0f / sqrt(DotProduct(v, v));
 383                                 data[side][y][x][2] = (unsigned char)(128.0f + intensity * v[0]);
 384                                 data[side][y][x][1] = (unsigned char)(128.0f + intensity * v[1]);
 385                                 data[side][y][x][0] = (unsigned char)(128.0f + intensity * v[2]);
 386                                 data[side][y][x][3] = 255;
 387                         }
 388                 }
 389         }
 390         r_texture_normalizationcube = R_LoadTextureCubeMap(r_main_texturepool, "normalcube", NORMSIZE, &data[0][0][0][0], TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_PERSISTENT, NULL);
 391 }
 392
 393 static void R_BuildFogTexture(void)
 394 {
 395         int x, b;
 396 #define FOGWIDTH 256
 397         unsigned char data1[FOGWIDTH][4];
 398         //unsigned char data2[FOGWIDTH][4];
 399         double d, r, alpha;
 400
 401         r_refdef.fogmasktable_start = r_refdef.fog_start;
 402         r_refdef.fogmasktable_alpha = r_refdef.fog_alpha;
 403         r_refdef.fogmasktable_range = r_refdef.fogrange;
 404         r_refdef.fogmasktable_density = r_refdef.fog_density;
 405
 406         r = r_refdef.fogmasktable_range / FOGMASKTABLEWIDTH;
 407         for (x = 0;x < FOGMASKTABLEWIDTH;x++)
 408         {
 409                 d = (x * r - r_refdef.fogmasktable_start);
 410                 if(developer.integer >= 100)
 411                         Con_Printf("%f ", d);
 412                 d = max(0, d);
 413                 if (r_fog_exp2.integer)
 414                         alpha = exp(-r_refdef.fogmasktable_density * r_refdef.fogmasktable_density * 0.0001 * d * d);
 415                 else
 416                         alpha = exp(-r_refdef.fogmasktable_density * 0.004 * d);
 417                 if(developer.integer >= 100)
 418                         Con_Printf(" : %f ", alpha);
 419                 alpha = 1 - (1 - alpha) * r_refdef.fogmasktable_alpha;
 420                 if(developer.integer >= 100)
 421                         Con_Printf(" = %f\n", alpha);
 422                 r_refdef.fogmasktable[x] = bound(0, alpha, 1);
 423         }
 424
 425         for (x = 0;x < FOGWIDTH;x++)
 426         {
 427                 b = (int)(r_refdef.fogmasktable[x * (FOGMASKTABLEWIDTH - 1) / (FOGWIDTH - 1)] * 255);
 428                 data1[x][0] = b;
 429                 data1[x][1] = b;
 430                 data1[x][2] = b;
 431                 data1[x][3] = 255;
 432                 //data2[x][0] = 255 - b;
 433                 //data2[x][1] = 255 - b;
 434                 //data2[x][2] = 255 - b;
 435                 //data2[x][3] = 255;
 436         }
 437         if (r_texture_fogattenuation)
 438         {
 439                 R_UpdateTexture(r_texture_fogattenuation, &data1[0][0], 0, 0, FOGWIDTH, 1);
 440                 //R_UpdateTexture(r_texture_fogattenuation, &data2[0][0], 0, 0, FOGWIDTH, 1);
 441         }
 442         else
 443         {
 444                 r_texture_fogattenuation = R_LoadTexture2D(r_main_texturepool, "fogattenuation", FOGWIDTH, 1, &data1[0][0], TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT, NULL);
 445                 //r_texture_fogintensity = R_LoadTexture2D(r_main_texturepool, "fogintensity", FOGWIDTH, 1, &data2[0][0], TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_FORCELINEAR | TEXF_CLAMP, NULL);
 446         }
 447 }
 448
 449 static const char *builtinshaderstring =
 450 "// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
 451 "// written by Forest 'LordHavoc' Hale\n"
 452 "\n"
 453 "// common definitions between vertex shader and fragment shader:\n"
 454 "\n"
 455 "//#ifdef __GLSL_CG_DATA_TYPES\n"
 456 "//# define myhalf half\n"
 457 "//# define myhalf2 half2\n"
 458 "//# define myhalf3 half3\n"
 459 "//# define myhalf4 half4\n"
 460 "//#else\n"
 461 "# define myhalf float\n"
 462 "# define myhalf2 vec2\n"
 463 "# define myhalf3 vec3\n"
 464 "# define myhalf4 vec4\n"
 465 "//#endif\n"
 466 "\n"
 467 "#ifdef MODE_DEPTH_OR_SHADOW\n"
 468 "\n"
 469 "# ifdef VERTEX_SHADER\n"
 470 "void main(void)\n"
 471 "{\n"
 472 "       gl_Position = ftransform();\n"
 473 "}\n"
 474 "# endif\n"
 475 "\n"
 476 "#else\n"
 477 "\n"
 478 "#ifdef MODE_POSTPROCESS\n"
 479 "# ifdef VERTEX_SHADER\n"
 480 "void main(void)\n"
 481 "{\n"
 482 "       gl_FrontColor = gl_Color;\n"
 483 "       gl_Position = ftransform();\n"
 484 "       gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;\n"
 485 "#ifdef USEGLOW\n"
 486 "       gl_TexCoord[1] = gl_TextureMatrix[1] * gl_MultiTexCoord1;\n"
 487 "#endif\n"
 488 "}\n"
 489 "# endif\n"
 490 "# ifdef FRAGMENT_SHADER\n"
 491 "\n"
 492 "uniform sampler2D Texture_First;\n"
 493 "#ifdef USEGLOW\n"
 494 "uniform sampler2D Texture_Second;\n"
 495 "#endif\n"
 496 "#ifdef USEVERTEXTEXTUREBLEND\n"
 497 "uniform vec4 TintColor;\n"
 498 "#endif\n"
 499 "#ifdef USECOLORMOD\n"
 500 "uniform vec3 Gamma;\n"
 501 "#endif\n"
 502 "#ifdef USECONTRASTBOOST\n"
 503 "uniform float ContrastBoostCoeff;\n"
 504 "#endif\n"
 505 "#ifdef USEGAMMA\n"
 506 "uniform float GammaCoeff;\n"
 507 "#endif\n"
 508 "//uncomment these if you want to use them:\n"
 509 "// uniform vec4 UserVec1;\n"
 510 "// uniform vec4 UserVec2;\n"
 511 "// uniform vec4 UserVec3;\n"
 512 "// uniform vec4 UserVec4;\n"
 513 "// uniform float ClientTime;\n"
 514 "void main(void)\n"
 515 "{\n"
 516 "       gl_FragColor = texture2D(Texture_First, gl_TexCoord[0].xy);\n"
 517 "#ifdef USEGLOW\n"
 518 "       gl_FragColor += texture2D(Texture_Second, gl_TexCoord[1].xy);\n"
 519 "#endif\n"
 520 "#ifdef USECONTRASTBOOST\n"
 521 "       gl_FragColor.rgb /= (ContrastBoostCoeff * gl_FragColor.rgb + vec3(1.0, 1.0, 1.0));\n"
 522 "       gl_FragColor.rgb *= (ContrastBoostCoeff + 1.0);\n"
 523 "#endif\n"
 524 "#ifdef USEGAMMA\n"
 525 "       gl_FragColor.rgb = pow(gl_FragColor.rgb, GammaCoeff);\n"
 526 "#endif\n"
 527 "#ifdef USEVERTEXTEXTUREBLEND\n"
 528 "       gl_FragColor = mix(TintColor, gl_FragColor, TintColor.a);\n"
 529 "#endif\n"
 530 "\n"
 531 "#ifdef USEPOSTPROCESSING\n"
 532 "// add your own postprocessing here or make your own ifdef for it\n"
 533 "#endif\n"
 534 "\n"
 535 "}\n"
 536 "# endif\n"
 537 "\n"
 538 "\n"
 539 "#else\n"
 540 "#ifdef MODE_GENERIC\n"
 541 "# ifdef VERTEX_SHADER\n"
 542 "void main(void)\n"
 543 "{\n"
 544 "       gl_FrontColor = gl_Color;\n"
 545 "#  ifdef USEDIFFUSE\n"
 546 "       gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;\n"
 547 "#  endif\n"
 548 "#  ifdef USESPECULAR\n"
 549 "       gl_TexCoord[1] = gl_TextureMatrix[1] * gl_MultiTexCoord1;\n"
 550 "#  endif\n"
 551 "       gl_Position = ftransform();\n"
 552 "}\n"
 553 "# endif\n"
 554 "# ifdef FRAGMENT_SHADER\n"
 555 "\n"
 556 "#  ifdef USEDIFFUSE\n"
 557 "uniform sampler2D Texture_First;\n"
 558 "#  endif\n"
 559 "#  ifdef USESPECULAR\n"
 560 "uniform sampler2D Texture_Second;\n"
 561 "#  endif\n"
 562 "\n"
 563 "void main(void)\n"
 564 "{\n"
 565 "       gl_FragColor = gl_Color;\n"
 566 "#  ifdef USEDIFFUSE\n"
 567 "       gl_FragColor *= texture2D(Texture_First, gl_TexCoord[0].xy);\n"
 568 "#  endif\n"
 569 "\n"
 570 "#  ifdef USESPECULAR\n"
 571 "       vec4 tex2 = texture2D(Texture_Second, gl_TexCoord[1].xy);\n"
 572 "#  endif\n"
 573 "#  ifdef USECOLORMAPPING\n"
 574 "       gl_FragColor *= tex2;\n"
 575 "#  endif\n"
 576 "#  ifdef USEGLOW\n"
 577 "       gl_FragColor += tex2;\n"
 578 "#  endif\n"
 579 "#  ifdef USEVERTEXTEXTUREBLEND\n"
 580 "       gl_FragColor = mix(tex2, gl_FragColor, tex2.a);\n"
 581 "#  endif\n"
 582 "}\n"
 583 "# endif\n"
 584 "\n"
 585 "#else // !MODE_GENERIC\n"
 586 "\n"
 587 "varying vec2 TexCoord;\n"
 588 "varying vec2 TexCoordLightmap;\n"
 589 "\n"
 590 "#ifdef MODE_LIGHTSOURCE\n"
 591 "varying vec3 CubeVector;\n"
 592 "#endif\n"
 593 "\n"
 594 "#ifdef MODE_LIGHTSOURCE\n"
 595 "varying vec3 LightVector;\n"
 596 "#endif\n"
 597 "#ifdef MODE_LIGHTDIRECTION\n"
 598 "varying vec3 LightVector;\n"
 599 "#endif\n"
 600 "\n"
 601 "varying vec3 EyeVector;\n"
 602 "#ifdef USEFOG\n"
 603 "varying vec3 EyeVectorModelSpace;\n"
 604 "#endif\n"
 605 "\n"
 606 "varying vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n"
 607 "varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
 608 "varying vec3 VectorR; // direction of R texcoord (surface normal)\n"
 609 "\n"
 610 "#ifdef MODE_WATER\n"
 611 "varying vec4 ModelViewProjectionPosition;\n"
 612 "#ifdef MODE_REFRACTION\n"
 613 "varying vec4 ModelViewProjectionPosition;\n"
 614 "#else\n"
 615 "# ifdef USEREFLECTION\n"
 616 "varying vec4 ModelViewProjectionPosition;\n"
 617 "# endif\n"
 618 "#endif\n"
 619 "#endif\n"
 620 "\n"
 621 "\n"
 622 "\n"
 623 "\n"
 624 "\n"
 625 "// vertex shader specific:\n"
 626 "#ifdef VERTEX_SHADER\n"
 627 "\n"
 628 "uniform vec3 LightPosition;\n"
 629 "uniform vec3 EyePosition;\n"
 630 "uniform vec3 LightDir;\n"
 631 "\n"
 632 "// TODO: get rid of tangentt (texcoord2) and use a crossproduct to regenerate it from tangents (texcoord1) and normal (texcoord3), this would require sending a 4 component texcoord1 with W as 1 or -1 according to which side the texcoord2 should be on\n"
 633 "\n"
 634 "void main(void)\n"
 635 "{\n"
 636 "       gl_FrontColor = gl_Color;\n"
 637 "       // copy the surface texcoord\n"
 638 "       TexCoord = vec2(gl_TextureMatrix[0] * gl_MultiTexCoord0);\n"
 639 "#ifndef MODE_LIGHTSOURCE\n"
 640 "# ifndef MODE_LIGHTDIRECTION\n"
 641 "       TexCoordLightmap = vec2(gl_MultiTexCoord4);\n"
 642 "# endif\n"
 643 "#endif\n"
 644 "\n"
 645 "#ifdef MODE_LIGHTSOURCE\n"
 646 "       // transform vertex position into light attenuation/cubemap space\n"
 647 "       // (-1 to +1 across the light box)\n"
 648 "       CubeVector = vec3(gl_TextureMatrix[3] * gl_Vertex);\n"
 649 "\n"
 650 "       // transform unnormalized light direction into tangent space\n"
 651 "       // (we use unnormalized to ensure that it interpolates correctly and then\n"
 652 "       //  normalize it per pixel)\n"
 653 "       vec3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
 654 "       LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
 655 "       LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
 656 "       LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
 657 "#endif\n"
 658 "\n"
 659 "#ifdef MODE_LIGHTDIRECTION\n"
 660 "       LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);\n"
 661 "       LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);\n"
 662 "       LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);\n"
 663 "#endif\n"
 664 "\n"
 665 "       // transform unnormalized eye direction into tangent space\n"
 666 "#ifndef USEFOG\n"
 667 "       vec3 EyeVectorModelSpace;\n"
 668 "#endif\n"
 669 "       EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
 670 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
 671 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
 672 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
 673 "\n"
 674 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
 675 "       VectorS = gl_MultiTexCoord1.xyz;\n"
 676 "       VectorT = gl_MultiTexCoord2.xyz;\n"
 677 "       VectorR = gl_MultiTexCoord3.xyz;\n"
 678 "#endif\n"
 679 "\n"
 680 "//#if defined(MODE_WATER) || defined(MODE_REFRACTION) || defined(USEREFLECTION)\n"
 681 "//     ModelViewProjectionPosition = gl_Vertex * gl_ModelViewProjectionMatrix;\n"
 682 "//     //ModelViewProjectionPosition_svector = (gl_Vertex + vec4(gl_MultiTexCoord1.xyz, 0)) * gl_ModelViewProjectionMatrix - ModelViewProjectionPosition;\n"
 683 "//     //ModelViewProjectionPosition_tvector = (gl_Vertex + vec4(gl_MultiTexCoord2.xyz, 0)) * gl_ModelViewProjectionMatrix - ModelViewProjectionPosition;\n"
 684 "//#endif\n"
 685 "\n"
 686 "// transform vertex to camera space, using ftransform to match non-VS\n"
 687 "       // rendering\n"
 688 "       gl_Position = ftransform();\n"
 689 "\n"
 690 "#ifdef MODE_WATER\n"
 691 "       ModelViewProjectionPosition = gl_Position;\n"
 692 "#endif\n"
 693 "#ifdef MODE_REFRACTION\n"
 694 "       ModelViewProjectionPosition = gl_Position;\n"
 695 "#endif\n"
 696 "#ifdef USEREFLECTION\n"
 697 "       ModelViewProjectionPosition = gl_Position;\n"
 698 "#endif\n"
 699 "}\n"
 700 "\n"
 701 "#endif // VERTEX_SHADER\n"
 702 "\n"
 703 "\n"
 704 "\n"
 705 "\n"
 706 "// fragment shader specific:\n"
 707 "#ifdef FRAGMENT_SHADER\n"
 708 "\n"
 709 "// 13 textures, we can only use up to 16 on DX9-class hardware\n"
 710 "uniform sampler2D Texture_Normal;\n"
 711 "uniform sampler2D Texture_Color;\n"
 712 "uniform sampler2D Texture_Gloss;\n"
 713 "uniform sampler2D Texture_Glow;\n"
 714 "uniform sampler2D Texture_SecondaryNormal;\n"
 715 "uniform sampler2D Texture_SecondaryColor;\n"
 716 "uniform sampler2D Texture_SecondaryGloss;\n"
 717 "uniform sampler2D Texture_SecondaryGlow;\n"
 718 "uniform sampler2D Texture_Pants;\n"
 719 "uniform sampler2D Texture_Shirt;\n"
 720 "uniform sampler2D Texture_FogMask;\n"
 721 "uniform sampler2D Texture_Lightmap;\n"
 722 "uniform sampler2D Texture_Deluxemap;\n"
 723 "uniform sampler2D Texture_Refraction;\n"
 724 "uniform sampler2D Texture_Reflection;\n"
 725 "uniform sampler2D Texture_Attenuation;\n"
 726 "uniform samplerCube Texture_Cube;\n"
 727 "\n"
 728 "uniform myhalf3 LightColor;\n"
 729 "uniform myhalf3 AmbientColor;\n"
 730 "uniform myhalf3 DiffuseColor;\n"
 731 "uniform myhalf3 SpecularColor;\n"
 732 "uniform myhalf3 Color_Pants;\n"
 733 "uniform myhalf3 Color_Shirt;\n"
 734 "uniform myhalf3 FogColor;\n"
 735 "\n"
 736 "uniform myhalf4 TintColor;\n"
 737 "\n"
 738 "\n"
 739 "//#ifdef MODE_WATER\n"
 740 "uniform vec4 DistortScaleRefractReflect;\n"
 741 "uniform vec4 ScreenScaleRefractReflect;\n"
 742 "uniform vec4 ScreenCenterRefractReflect;\n"
 743 "uniform myhalf4 RefractColor;\n"
 744 "uniform myhalf4 ReflectColor;\n"
 745 "uniform myhalf ReflectFactor;\n"
 746 "uniform myhalf ReflectOffset;\n"
 747 "//#else\n"
 748 "//# ifdef MODE_REFRACTION\n"
 749 "//uniform vec4 DistortScaleRefractReflect;\n"
 750 "//uniform vec4 ScreenScaleRefractReflect;\n"
 751 "//uniform vec4 ScreenCenterRefractReflect;\n"
 752 "//uniform myhalf4 RefractColor;\n"
 753 "//#  ifdef USEREFLECTION\n"
 754 "//uniform myhalf4 ReflectColor;\n"
 755 "//#  endif\n"
 756 "//# else\n"
 757 "//#  ifdef USEREFLECTION\n"
 758 "//uniform vec4 DistortScaleRefractReflect;\n"
 759 "//uniform vec4 ScreenScaleRefractReflect;\n"
 760 "//uniform vec4 ScreenCenterRefractReflect;\n"
 761 "//uniform myhalf4 ReflectColor;\n"
 762 "//#  endif\n"
 763 "//# endif\n"
 764 "//#endif\n"
 765 "\n"
 766 "uniform myhalf GlowScale;\n"
 767 "uniform myhalf SceneBrightness;\n"
 768 "#ifdef USECONTRASTBOOST\n"
 769 "uniform myhalf ContrastBoostCoeff;\n"
 770 "#endif\n"
 771 "\n"
 772 "uniform float OffsetMapping_Scale;\n"
 773 "uniform float OffsetMapping_Bias;\n"
 774 "uniform float FogRangeRecip;\n"
 775 "\n"
 776 "uniform myhalf AmbientScale;\n"
 777 "uniform myhalf DiffuseScale;\n"
 778 "uniform myhalf SpecularScale;\n"
 779 "uniform myhalf SpecularPower;\n"
 780 "\n"
 781 "#ifdef USEOFFSETMAPPING\n"
 782 "vec2 OffsetMapping(vec2 TexCoord)\n"
 783 "{\n"
 784 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
 785 "       // 14 sample relief mapping: linear search and then binary search\n"
 786 "       // this basically steps forward a small amount repeatedly until it finds\n"
 787 "       // itself inside solid, then jitters forward and back using decreasing\n"
 788 "       // amounts to find the impact\n"
 789 "       //vec3 OffsetVector = vec3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1), -1);\n"
 790 "       //vec3 OffsetVector = vec3(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
 791 "       vec3 OffsetVector = vec3(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
 792 "       vec3 RT = vec3(TexCoord, 1);\n"
 793 "       OffsetVector *= 0.1;\n"
 794 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
 795 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
 796 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
 797 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
 798 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
 799 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
 800 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
 801 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
 802 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
 803 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z)          - 0.5);\n"
 804 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.5    - 0.25);\n"
 805 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.25   - 0.125);\n"
 806 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.125  - 0.0625);\n"
 807 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
 808 "       return RT.xy;\n"
 809 "#else\n"
 810 "       // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
 811 "       // this basically moves forward the full distance, and then backs up based\n"
 812 "       // on height of samples\n"
 813 "       //vec2 OffsetVector = vec2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1));\n"
 814 "       //vec2 OffsetVector = vec2(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1));\n"
 815 "       vec2 OffsetVector = vec2(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1));\n"
 816 "       TexCoord += OffsetVector;\n"
 817 "       OffsetVector *= 0.333;\n"
 818 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
 819 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
 820 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
 821 "       return TexCoord;\n"
 822 "#endif\n"
 823 "}\n"
 824 "#endif // USEOFFSETMAPPING\n"
 825 "\n"
 826 "#ifdef MODE_WATER\n"
 827 "\n"
 828 "// water pass\n"
 829 "void main(void)\n"
 830 "{\n"
 831 "#ifdef USEOFFSETMAPPING\n"
 832 "       // apply offsetmapping\n"
 833 "       vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
 834 "#define TexCoord TexCoordOffset\n"
 835 "#endif\n"
 836 "\n"
 837 "       vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
 838 "       //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
 839 "       vec4 ScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect + vec2(normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5))).xyxy * DistortScaleRefractReflect;\n"
 840 "       float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 2.0) * ReflectFactor + ReflectOffset;\n"
 841 "       gl_FragColor = mix(texture2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, texture2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n"
 842 "}\n"
 843 "\n"
 844 "#else // !MODE_WATER\n"
 845 "#ifdef MODE_REFRACTION\n"
 846 "\n"
 847 "// refraction pass\n"
 848 "void main(void)\n"
 849 "{\n"
 850 "#ifdef USEOFFSETMAPPING\n"
 851 "       // apply offsetmapping\n"
 852 "       vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
 853 "#define TexCoord TexCoordOffset\n"
 854 "#endif\n"
 855 "\n"
 856 "       vec2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
 857 "       //vec2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
 858 "       vec2 ScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy + vec2(normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5))).xy * DistortScaleRefractReflect.xy;\n"
 859 "       gl_FragColor = texture2D(Texture_Refraction, ScreenTexCoord) * RefractColor;\n"
 860 "}\n"
 861 "\n"
 862 "#else // !MODE_REFRACTION\n"
 863 "void main(void)\n"
 864 "{\n"
 865 "#ifdef USEOFFSETMAPPING\n"
 866 "       // apply offsetmapping\n"
 867 "       vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
 868 "#define TexCoord TexCoordOffset\n"
 869 "#endif\n"
 870 "\n"
 871 "       // combine the diffuse textures (base, pants, shirt)\n"
 872 "       myhalf4 color = myhalf4(texture2D(Texture_Color, TexCoord));\n"
 873 "#ifdef USECOLORMAPPING\n"
 874 "       color.rgb += myhalf3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + myhalf3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
 875 "#endif\n"
 876 "#ifdef USEVERTEXTEXTUREBLEND\n"
 877 "       myhalf terrainblend = clamp(myhalf(gl_Color.a) * color.a * 2.0 - 0.5, myhalf(0.0), myhalf(1.0));\n"
 878 "       //myhalf terrainblend = min(myhalf(gl_Color.a) * color.a * 2.0, myhalf(1.0));\n"
 879 "       //myhalf terrainblend = myhalf(gl_Color.a) * color.a > 0.5;\n"
 880 "       color = mix(myhalf4(texture2D(Texture_SecondaryColor, TexCoord)), color, terrainblend);\n"
 881 "       //color = mix(myhalf4(1, 0, 0, 1), color, terrainblend);\n"
 882 "#endif\n"
 883 "\n"
 884 "#ifdef USEDIFFUSE\n"
 885 "       // get the surface normal and the gloss color\n"
 886 "# ifdef USEVERTEXTEXTUREBLEND\n"
 887 "       myhalf3 surfacenormal = normalize(mix(myhalf3(texture2D(Texture_SecondaryNormal, TexCoord)), myhalf3(texture2D(Texture_Normal, TexCoord)), terrainblend) - myhalf3(0.5, 0.5, 0.5));\n"
 888 "#  ifdef USESPECULAR\n"
 889 "       myhalf3 glosscolor = mix(myhalf3(texture2D(Texture_SecondaryGloss, TexCoord)), myhalf3(texture2D(Texture_Gloss, TexCoord)), terrainblend);\n"
 890 "#  endif\n"
 891 "# else\n"
 892 "       myhalf3 surfacenormal = normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5));\n"
 893 "#  ifdef USESPECULAR\n"
 894 "       myhalf3 glosscolor = myhalf3(texture2D(Texture_Gloss, TexCoord));\n"
 895 "#  endif\n"
 896 "# endif\n"
 897 "#endif\n"
 898 "\n"
 899 "\n"
 900 "\n"
 901 "#ifdef MODE_LIGHTSOURCE\n"
 902 "       // light source\n"
 903 "\n"
 904 "       // calculate surface normal, light normal, and specular normal\n"
 905 "       // compute color intensity for the two textures (colormap and glossmap)\n"
 906 "       // scale by light color and attenuation as efficiently as possible\n"
 907 "       // (do as much scalar math as possible rather than vector math)\n"
 908 "# ifdef USEDIFFUSE\n"
 909 "       // get the light normal\n"
 910 "       myhalf3 diffusenormal = myhalf3(normalize(LightVector));\n"
 911 "# endif\n"
 912 "# ifdef USESPECULAR\n"
 913 "       myhalf3 specularnormal = normalize(diffusenormal + myhalf3(normalize(EyeVector)));\n"
 914 "\n"
 915 "       // calculate directional shading\n"
 916 "       color.rgb = myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0))) * (color.rgb * (AmbientScale + DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0))) + (SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower)) * glosscolor);\n"
 917 "# else\n"
 918 "#  ifdef USEDIFFUSE\n"
 919 "       // calculate directional shading\n"
 920 "       color.rgb = color.rgb * (myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0))) * (AmbientScale + DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0))));\n"
 921 "#  else\n"
 922 "       // calculate directionless shading\n"
 923 "       color.rgb = color.rgb * myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
 924 "#  endif\n"
 925 "# endif\n"
 926 "\n"
 927 "# ifdef USECUBEFILTER\n"
 928 "       // apply light cubemap filter\n"
 929 "       //color.rgb *= normalize(CubeVector) * 0.5 + 0.5;//vec3(textureCube(Texture_Cube, CubeVector));\n"
 930 "       color.rgb *= myhalf3(textureCube(Texture_Cube, CubeVector));\n"
 931 "# endif\n"
 932 "#endif // MODE_LIGHTSOURCE\n"
 933 "\n"
 934 "\n"
 935 "\n"
 936 "\n"
 937 "#ifdef MODE_LIGHTDIRECTION\n"
 938 "       // directional model lighting\n"
 939 "# ifdef USEDIFFUSE\n"
 940 "       // get the light normal\n"
 941 "       myhalf3 diffusenormal = myhalf3(LightVector);\n"
 942 "# endif\n"
 943 "# ifdef USESPECULAR\n"
 944 "       // calculate directional shading\n"
 945 "       color.rgb *= AmbientColor + DiffuseColor * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
 946 "       myhalf3 specularnormal = normalize(diffusenormal + myhalf3(normalize(EyeVector)));\n"
 947 "       color.rgb += myhalf3(texture2D(Texture_Gloss, TexCoord)) * SpecularColor * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
 948 "# else\n"
 949 "#  ifdef USEDIFFUSE\n"
 950 "\n"
 951 "       // calculate directional shading\n"
 952 "       color.rgb *= AmbientColor + DiffuseColor * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
 953 "#  else\n"
 954 "       color.rgb *= AmbientColor;\n"
 955 "#  endif\n"
 956 "# endif\n"
 957 "#endif // MODE_LIGHTDIRECTION\n"
 958 "\n"
 959 "\n"
 960 "\n"
 961 "\n"
 962 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
 963 "       // deluxemap lightmapping using light vectors in modelspace (evil q3map2)\n"
 964 "\n"
 965 "       // get the light normal\n"
 966 "       myhalf3 diffusenormal_modelspace = myhalf3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - myhalf3(0.5);\n"
 967 "       myhalf3 diffusenormal = normalize(myhalf3(dot(diffusenormal_modelspace, myhalf3(VectorS)), dot(diffusenormal_modelspace, myhalf3(VectorT)), dot(diffusenormal_modelspace, myhalf3(VectorR))));\n"
 968 "       // calculate directional shading\n"
 969 "       myhalf3 tempcolor = color.rgb * (DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0)));\n"
 970 "# ifdef USESPECULAR\n"
 971 "       myhalf3 specularnormal = myhalf3(normalize(diffusenormal + myhalf3(normalize(EyeVector))));\n"
 972 "       tempcolor += myhalf3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
 973 "# endif\n"
 974 "\n"
 975 "       // apply lightmap color\n"
 976 "       color.rgb = color.rgb * AmbientScale + tempcolor * myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap));\n"
 977 "#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
 978 "\n"
 979 "\n"
 980 "\n"
 981 "\n"
 982 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
 983 "       // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
 984 "\n"
 985 "       // get the light normal\n"
 986 "       myhalf3 diffusenormal = normalize(myhalf3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - myhalf3(0.5));\n"
 987 "       // calculate directional shading\n"
 988 "       myhalf3 tempcolor = color.rgb * (DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0)));\n"
 989 "# ifdef USESPECULAR\n"
 990 "       myhalf3 specularnormal = myhalf3(normalize(diffusenormal + myhalf3(normalize(EyeVector))));\n"
 991 "       tempcolor += myhalf3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
 992 "# endif\n"
 993 "\n"
 994 "       // apply lightmap color\n"
 995 "       color.rgb = color.rgb * AmbientScale + tempcolor * myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap));\n"
 996 "#endif // MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
 997 "\n"
 998 "\n"
 999 "\n"
1000 "\n"
1001 "#ifdef MODE_LIGHTMAP\n"
1002 "       // apply lightmap color\n"
1003 "       color.rgb = color.rgb * myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap)) * DiffuseScale + color.rgb * AmbientScale;\n"
1004 "#endif // MODE_LIGHTMAP\n"
1005 "\n"
1006 "\n"
1007 "\n"
1008 "\n"
1009 "#ifdef MODE_VERTEXCOLOR\n"
1010 "       // apply lightmap color\n"
1011 "       color.rgb = color.rgb * myhalf3(gl_Color.rgb) * DiffuseScale + color.rgb * AmbientScale;\n"
1012 "#endif // MODE_VERTEXCOLOR\n"
1013 "\n"
1014 "\n"
1015 "\n"
1016 "\n"
1017 "#ifdef MODE_FLATCOLOR\n"
1018 "#endif // MODE_FLATCOLOR\n"
1019 "\n"
1020 "\n"
1021 "\n"
1022 "\n"
1023 "\n"
1024 "\n"
1025 "\n"
1026 "       color *= TintColor;\n"
1027 "\n"
1028 "#ifdef USEGLOW\n"
1029 "       color.rgb += myhalf3(texture2D(Texture_Glow, TexCoord)) * GlowScale;\n"
1030 "#endif\n"
1031 "\n"
1032 "#ifdef USECONTRASTBOOST\n"
1033 "       color.rgb = color.rgb / (ContrastBoostCoeff * color.rgb + myhalf3(1, 1, 1));\n"
1034 "#endif\n"
1035 "\n"
1036 "       color.rgb *= SceneBrightness;\n"
1037 "\n"
1038 "       // apply fog after Contrastboost/SceneBrightness because its color is already modified appropriately\n"
1039 "#ifdef USEFOG\n"
1040 "       color.rgb = mix(FogColor, color.rgb, myhalf(texture2D(Texture_FogMask, myhalf2(length(EyeVectorModelSpace)*FogRangeRecip, 0.0))));\n"
1041 "#endif\n"
1042 "\n"
1043 "       // reflection must come last because it already contains exactly the correct fog (the reflection render preserves camera distance from the plane, it only flips the side) and ContrastBoost/SceneBrightness\n"
1044 "#ifdef USEREFLECTION\n"
1045 "       vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
1046 "       //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
1047 "       vec4 ScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect + vec3(normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5))).xyxy * DistortScaleRefractReflect;\n"
1048 "       color.rgb = mix(color.rgb, myhalf3(texture2D(Texture_Reflection, ScreenTexCoord.zw)) * ReflectColor.rgb, ReflectColor.a);\n"
1049 "#endif\n"
1050 "\n"
1051 "       gl_FragColor = vec4(color);\n"
1052 "}\n"
1053 "#endif // !MODE_REFRACTION\n"
1054 "#endif // !MODE_WATER\n"
1055 "\n"
1056 "#endif // FRAGMENT_SHADER\n"
1057 "\n"
1058 "#endif // !MODE_GENERIC\n"
1059 "#endif // !MODE_POSTPROCESS\n"
1060 "#endif // !MODE_DEPTH_OR_SHADOW\n"
1061 ;
1062
1063 typedef struct shaderpermutationinfo_s
1064 {
1065         const char *pretext;
1066         const char *name;
1067 }
1068 shaderpermutationinfo_t;
1069
1070 typedef struct shadermodeinfo_s
1071 {
1072         const char *vertexfilename;
1073         const char *geometryfilename;
1074         const char *fragmentfilename;
1075         const char *pretext;
1076         const char *name;
1077 }
1078 shadermodeinfo_t;
1079
1080 typedef enum shaderpermutation_e
1081 {
1082         SHADERPERMUTATION_DIFFUSE = 1<<0, // (lightsource) whether to use directional shading
1083         SHADERPERMUTATION_VERTEXTEXTUREBLEND = 1<<1, // indicates this is a two-layer material blend based on vertex alpha (q3bsp)
1084         SHADERPERMUTATION_COLORMAPPING = 1<<2, // indicates this is a colormapped skin
1085         SHADERPERMUTATION_CONTRASTBOOST = 1<<3, // r_glsl_contrastboost boosts the contrast at low color levels (similar to gamma)
1086         SHADERPERMUTATION_FOG = 1<<4, // tint the color by fog color or black if using additive blend mode
1087         SHADERPERMUTATION_CUBEFILTER = 1<<5, // (lightsource) use cubemap light filter
1088         SHADERPERMUTATION_GLOW = 1<<6, // (lightmap) blend in an additive glow texture
1089         SHADERPERMUTATION_SPECULAR = 1<<7, // (lightsource or deluxemapping) render specular effects
1090         SHADERPERMUTATION_REFLECTION = 1<<8, // normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface
1091         SHADERPERMUTATION_OFFSETMAPPING = 1<<9, // adjust texcoords to roughly simulate a displacement mapped surface
1092         SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING = 1<<10, // adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!)
1093         SHADERPERMUTATION_GAMMA = 1<<11, // gamma (postprocessing only)
1094         SHADERPERMUTATION_POSTPROCESSING = 1<<12, // gamma (postprocessing only)
1095         SHADERPERMUTATION_LIMIT = 1<<13, // size of permutations array
1096         SHADERPERMUTATION_COUNT = 13 // size of shaderpermutationinfo array
1097 }
1098 shaderpermutation_t;
1099
1100 // NOTE: MUST MATCH ORDER OF SHADERPERMUTATION_* DEFINES!
1101 shaderpermutationinfo_t shaderpermutationinfo[SHADERPERMUTATION_COUNT] =
1102 {
1103         {"#define USEDIFFUSE\n", " diffuse"},
1104         {"#define USEVERTEXTEXTUREBLEND\n", " vertextextureblend"},
1105         {"#define USECOLORMAPPING\n", " colormapping"},
1106         {"#define USECONTRASTBOOST\n", " contrastboost"},
1107         {"#define USEFOG\n", " fog"},
1108         {"#define USECUBEFILTER\n", " cubefilter"},
1109         {"#define USEGLOW\n", " glow"},
1110         {"#define USESPECULAR\n", " specular"},
1111         {"#define USEREFLECTION\n", " reflection"},
1112         {"#define USEOFFSETMAPPING\n", " offsetmapping"},
1113         {"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"},
1114         {"#define USEGAMMA\n", " gamma"},
1115         {"#define USEPOSTPROCESSING\n", " postprocessing"},
1116 };
1117
1118 // this enum is multiplied by SHADERPERMUTATION_MODEBASE
1119 typedef enum shadermode_e
1120 {
1121         SHADERMODE_GENERIC, // (particles/HUD/etc) vertex color, optionally multiplied by one texture
1122         SHADERMODE_POSTPROCESS, // postprocessing shader (r_glsl_postprocess)
1123         SHADERMODE_DEPTH_OR_SHADOW, // (depthfirst/shadows) vertex shader only
1124         SHADERMODE_FLATCOLOR, // (lightmap) modulate texture by uniform color (q1bsp, q3bsp)
1125         SHADERMODE_VERTEXCOLOR, // (lightmap) modulate texture by vertex colors (q3bsp)
1126         SHADERMODE_LIGHTMAP, // (lightmap) modulate texture by lightmap texture (q1bsp, q3bsp)
1127         SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE, // (lightmap) use directional pixel shading from texture containing modelspace light directions (q3bsp deluxemap)
1128         SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE, // (lightmap) use directional pixel shading from texture containing tangentspace light directions (q1bsp deluxemap)
1129         SHADERMODE_LIGHTDIRECTION, // (lightmap) use directional pixel shading from fixed light direction (q3bsp)
1130         SHADERMODE_LIGHTSOURCE, // (lightsource) use directional pixel shading from light source (rtlight)
1131         SHADERMODE_REFRACTION, // refract background (the material is rendered normally after this pass)
1132         SHADERMODE_WATER, // refract background and reflection (the material is rendered normally after this pass)
1133         SHADERMODE_COUNT
1134 }
1135 shadermode_t;
1136
1137 // NOTE: MUST MATCH ORDER OF SHADERMODE_* ENUMS!
1138 shadermodeinfo_t shadermodeinfo[SHADERMODE_COUNT] =
1139 {
1140         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_GENERIC\n", " generic"},
1141         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_POSTPROCESS\n", " postprocess"},
1142         {"glsl/default.glsl", NULL, NULL               , "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"},
1143         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_FLATCOLOR\n", " flatcolor"},
1144         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
1145         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTMAP\n", " lightmap"},
1146         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
1147         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
1148         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
1149         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTSOURCE\n", " lightsource"},
1150         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_REFRACTION\n", " refraction"},
1151         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_WATER\n", " water"},
1152 };
1153
1154 typedef struct r_glsl_permutation_s
1155 {
1156         // indicates if we have tried compiling this permutation already
1157         qboolean compiled;
1158         // 0 if compilation failed
1159         int program;
1160         // locations of detected uniforms in program object, or -1 if not found
1161         int loc_Texture_First;
1162         int loc_Texture_Second;
1163         int loc_Texture_Normal;
1164         int loc_Texture_Color;
1165         int loc_Texture_Gloss;
1166         int loc_Texture_Glow;
1167         int loc_Texture_SecondaryNormal;
1168         int loc_Texture_SecondaryColor;
1169         int loc_Texture_SecondaryGloss;
1170         int loc_Texture_SecondaryGlow;
1171         int loc_Texture_Pants;
1172         int loc_Texture_Shirt;
1173         int loc_Texture_FogMask;
1174         int loc_Texture_Lightmap;
1175         int loc_Texture_Deluxemap;
1176         int loc_Texture_Attenuation;
1177         int loc_Texture_Cube;
1178         int loc_Texture_Refraction;
1179         int loc_Texture_Reflection;
1180         int loc_FogColor;
1181         int loc_LightPosition;
1182         int loc_EyePosition;
1183         int loc_Color_Pants;
1184         int loc_Color_Shirt;
1185         int loc_FogRangeRecip;
1186         int loc_AmbientScale;
1187         int loc_DiffuseScale;
1188         int loc_SpecularScale;
1189         int loc_SpecularPower;
1190         int loc_GlowScale;
1191         int loc_SceneBrightness; // or: Scenebrightness * ContrastBoost
1192         int loc_OffsetMapping_Scale;
1193         int loc_TintColor;
1194         int loc_AmbientColor;
1195         int loc_DiffuseColor;
1196         int loc_SpecularColor;
1197         int loc_LightDir;
1198         int loc_ContrastBoostCoeff; // 1 - 1/ContrastBoost
1199         int loc_GammaCoeff; // 1 / gamma
1200         int loc_DistortScaleRefractReflect;
1201         int loc_ScreenScaleRefractReflect;
1202         int loc_ScreenCenterRefractReflect;
1203         int loc_RefractColor;
1204         int loc_ReflectColor;
1205         int loc_ReflectFactor;
1206         int loc_ReflectOffset;
1207         int loc_UserVec1;
1208         int loc_UserVec2;
1209         int loc_UserVec3;
1210         int loc_UserVec4;
1211         int loc_ClientTime;
1212 }
1213 r_glsl_permutation_t;
1214
1215 // information about each possible shader permutation
1216 r_glsl_permutation_t r_glsl_permutations[SHADERMODE_COUNT][SHADERPERMUTATION_LIMIT];
1217 // currently selected permutation
1218 r_glsl_permutation_t *r_glsl_permutation;
1219
1220 static char *R_GLSL_GetText(const char *filename, qboolean printfromdisknotice)
1221 {
1222         char *shaderstring;
1223         if (!filename || !filename[0])
1224                 return NULL;
1225         shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
1226         if (shaderstring)
1227         {
1228                 if (printfromdisknotice)
1229                         Con_DPrint("from disk... ");
1230                 return shaderstring;
1231         }
1232         else if (!strcmp(filename, "glsl/default.glsl"))
1233         {
1234                 shaderstring = Mem_Alloc(r_main_mempool, strlen(builtinshaderstring) + 1);
1235                 memcpy(shaderstring, builtinshaderstring, strlen(builtinshaderstring) + 1);
1236         }
1237         return shaderstring;
1238 }
1239
1240 static void R_GLSL_CompilePermutation(shadermode_t mode, shaderpermutation_t permutation)
1241 {
1242         int i;
1243         shadermodeinfo_t *modeinfo = shadermodeinfo + mode;
1244         r_glsl_permutation_t *p = &r_glsl_permutations[mode][permutation];
1245         int vertstrings_count = 0;
1246         int geomstrings_count = 0;
1247         int fragstrings_count = 0;
1248         char *vertexstring, *geometrystring, *fragmentstring;
1249         const char *vertstrings_list[32+3];
1250         const char *geomstrings_list[32+3];
1251         const char *fragstrings_list[32+3];
1252         char permutationname[256];
1253
1254         if (p->compiled)
1255                 return;
1256         p->compiled = true;
1257         p->program = 0;
1258
1259         permutationname[0] = 0;
1260         vertexstring   = R_GLSL_GetText(modeinfo->vertexfilename, true);
1261         geometrystring = R_GLSL_GetText(modeinfo->geometryfilename, false);
1262         fragmentstring = R_GLSL_GetText(modeinfo->fragmentfilename, false);
1263
1264         strlcat(permutationname, shadermodeinfo[mode].vertexfilename, sizeof(permutationname));
1265
1266         // the first pretext is which type of shader to compile as
1267         // (later these will all be bound together as a program object)
1268         vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
1269         geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
1270         fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
1271
1272         // the second pretext is the mode (for example a light source)
1273         vertstrings_list[vertstrings_count++] = shadermodeinfo[mode].pretext;
1274         geomstrings_list[geomstrings_count++] = shadermodeinfo[mode].pretext;
1275         fragstrings_list[fragstrings_count++] = shadermodeinfo[mode].pretext;
1276         strlcat(permutationname, modeinfo->name, sizeof(permutationname));
1277
1278         // now add all the permutation pretexts
1279         for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
1280         {
1281                 if (permutation & (1<<i))
1282                 {
1283                         vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
1284                         geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
1285                         fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
1286                         strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
1287                 }
1288                 else
1289                 {
1290                         // keep line numbers correct
1291                         vertstrings_list[vertstrings_count++] = "\n";
1292                         geomstrings_list[geomstrings_count++] = "\n";
1293                         fragstrings_list[fragstrings_count++] = "\n";
1294                 }
1295         }
1296
1297         // now append the shader text itself
1298         vertstrings_list[vertstrings_count++] = vertexstring;
1299         geomstrings_list[geomstrings_count++] = geometrystring;
1300         fragstrings_list[fragstrings_count++] = fragmentstring;
1301
1302         // if any sources were NULL, clear the respective list
1303         if (!vertexstring)
1304                 vertstrings_count = 0;
1305         if (!geometrystring)
1306                 geomstrings_count = 0;
1307         if (!fragmentstring)
1308                 fragstrings_count = 0;
1309
1310         // compile the shader program
1311         if (vertstrings_count + geomstrings_count + fragstrings_count)
1312                 p->program = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, geomstrings_count, geomstrings_list, fragstrings_count, fragstrings_list);
1313         if (p->program)
1314         {
1315                 CHECKGLERROR
1316                 qglUseProgramObjectARB(p->program);CHECKGLERROR
1317                 // look up all the uniform variable names we care about, so we don't
1318                 // have to look them up every time we set them
1319                 p->loc_Texture_First              = qglGetUniformLocationARB(p->program, "Texture_First");
1320                 p->loc_Texture_Second             = qglGetUniformLocationARB(p->program, "Texture_Second");
1321                 p->loc_Texture_Normal             = qglGetUniformLocationARB(p->program, "Texture_Normal");
1322                 p->loc_Texture_Color              = qglGetUniformLocationARB(p->program, "Texture_Color");
1323                 p->loc_Texture_Gloss              = qglGetUniformLocationARB(p->program, "Texture_Gloss");
1324                 p->loc_Texture_Glow               = qglGetUniformLocationARB(p->program, "Texture_Glow");
1325                 p->loc_Texture_SecondaryNormal    = qglGetUniformLocationARB(p->program, "Texture_SecondaryNormal");
1326                 p->loc_Texture_SecondaryColor     = qglGetUniformLocationARB(p->program, "Texture_SecondaryColor");
1327                 p->loc_Texture_SecondaryGloss     = qglGetUniformLocationARB(p->program, "Texture_SecondaryGloss");
1328                 p->loc_Texture_SecondaryGlow      = qglGetUniformLocationARB(p->program, "Texture_SecondaryGlow");
1329                 p->loc_Texture_FogMask            = qglGetUniformLocationARB(p->program, "Texture_FogMask");
1330                 p->loc_Texture_Pants              = qglGetUniformLocationARB(p->program, "Texture_Pants");
1331                 p->loc_Texture_Shirt              = qglGetUniformLocationARB(p->program, "Texture_Shirt");
1332                 p->loc_Texture_Lightmap           = qglGetUniformLocationARB(p->program, "Texture_Lightmap");
1333                 p->loc_Texture_Deluxemap          = qglGetUniformLocationARB(p->program, "Texture_Deluxemap");
1334                 p->loc_Texture_Refraction         = qglGetUniformLocationARB(p->program, "Texture_Refraction");
1335                 p->loc_Texture_Reflection         = qglGetUniformLocationARB(p->program, "Texture_Reflection");
1336                 p->loc_Texture_Attenuation        = qglGetUniformLocationARB(p->program, "Texture_Attenuation");
1337                 p->loc_Texture_Cube               = qglGetUniformLocationARB(p->program, "Texture_Cube");
1338                 p->loc_FogColor                   = qglGetUniformLocationARB(p->program, "FogColor");
1339                 p->loc_LightPosition              = qglGetUniformLocationARB(p->program, "LightPosition");
1340                 p->loc_EyePosition                = qglGetUniformLocationARB(p->program, "EyePosition");
1341                 p->loc_Color_Pants                = qglGetUniformLocationARB(p->program, "Color_Pants");
1342                 p->loc_Color_Shirt                = qglGetUniformLocationARB(p->program, "Color_Shirt");
1343                 p->loc_FogRangeRecip              = qglGetUniformLocationARB(p->program, "FogRangeRecip");
1344                 p->loc_AmbientScale               = qglGetUniformLocationARB(p->program, "AmbientScale");
1345                 p->loc_DiffuseScale               = qglGetUniformLocationARB(p->program, "DiffuseScale");
1346                 p->loc_SpecularPower              = qglGetUniformLocationARB(p->program, "SpecularPower");
1347                 p->loc_SpecularScale              = qglGetUniformLocationARB(p->program, "SpecularScale");
1348                 p->loc_GlowScale                  = qglGetUniformLocationARB(p->program, "GlowScale");
1349                 p->loc_SceneBrightness            = qglGetUniformLocationARB(p->program, "SceneBrightness");
1350                 p->loc_OffsetMapping_Scale        = qglGetUniformLocationARB(p->program, "OffsetMapping_Scale");
1351                 p->loc_TintColor                  = qglGetUniformLocationARB(p->program, "TintColor");
1352                 p->loc_AmbientColor               = qglGetUniformLocationARB(p->program, "AmbientColor");
1353                 p->loc_DiffuseColor               = qglGetUniformLocationARB(p->program, "DiffuseColor");
1354                 p->loc_SpecularColor              = qglGetUniformLocationARB(p->program, "SpecularColor");
1355                 p->loc_LightDir                   = qglGetUniformLocationARB(p->program, "LightDir");
1356                 p->loc_ContrastBoostCoeff         = qglGetUniformLocationARB(p->program, "ContrastBoostCoeff");
1357                 p->loc_DistortScaleRefractReflect = qglGetUniformLocationARB(p->program, "DistortScaleRefractReflect");
1358                 p->loc_ScreenScaleRefractReflect  = qglGetUniformLocationARB(p->program, "ScreenScaleRefractReflect");
1359                 p->loc_ScreenCenterRefractReflect = qglGetUniformLocationARB(p->program, "ScreenCenterRefractReflect");
1360                 p->loc_RefractColor               = qglGetUniformLocationARB(p->program, "RefractColor");
1361                 p->loc_ReflectColor               = qglGetUniformLocationARB(p->program, "ReflectColor");
1362                 p->loc_ReflectFactor              = qglGetUniformLocationARB(p->program, "ReflectFactor");
1363                 p->loc_ReflectOffset              = qglGetUniformLocationARB(p->program, "ReflectOffset");
1364                 p->loc_GammaCoeff                 = qglGetUniformLocationARB(p->program, "GammaCoeff");
1365                 p->loc_UserVec1                   = qglGetUniformLocationARB(p->program, "UserVec1");
1366                 p->loc_UserVec2                   = qglGetUniformLocationARB(p->program, "UserVec2");
1367                 p->loc_UserVec3                   = qglGetUniformLocationARB(p->program, "UserVec3");
1368                 p->loc_UserVec4                   = qglGetUniformLocationARB(p->program, "UserVec4");
1369                 p->loc_ClientTime                 = qglGetUniformLocationARB(p->program, "ClientTime");
1370                 // initialize the samplers to refer to the texture units we use
1371                 if (p->loc_Texture_First           >= 0) qglUniform1iARB(p->loc_Texture_First          , GL20TU_FIRST);
1372                 if (p->loc_Texture_Second          >= 0) qglUniform1iARB(p->loc_Texture_Second         , GL20TU_SECOND);
1373                 if (p->loc_Texture_Normal          >= 0) qglUniform1iARB(p->loc_Texture_Normal         , GL20TU_NORMAL);
1374                 if (p->loc_Texture_Color           >= 0) qglUniform1iARB(p->loc_Texture_Color          , GL20TU_COLOR);
1375                 if (p->loc_Texture_Gloss           >= 0) qglUniform1iARB(p->loc_Texture_Gloss          , GL20TU_GLOSS);
1376                 if (p->loc_Texture_Glow            >= 0) qglUniform1iARB(p->loc_Texture_Glow           , GL20TU_GLOW);
1377                 if (p->loc_Texture_SecondaryNormal >= 0) qglUniform1iARB(p->loc_Texture_SecondaryNormal, GL20TU_SECONDARY_NORMAL);
1378                 if (p->loc_Texture_SecondaryColor  >= 0) qglUniform1iARB(p->loc_Texture_SecondaryColor , GL20TU_SECONDARY_COLOR);
1379                 if (p->loc_Texture_SecondaryGloss  >= 0) qglUniform1iARB(p->loc_Texture_SecondaryGloss , GL20TU_SECONDARY_GLOSS);
1380                 if (p->loc_Texture_SecondaryGlow   >= 0) qglUniform1iARB(p->loc_Texture_SecondaryGlow  , GL20TU_SECONDARY_GLOW);
1381                 if (p->loc_Texture_Pants           >= 0) qglUniform1iARB(p->loc_Texture_Pants          , GL20TU_PANTS);
1382                 if (p->loc_Texture_Shirt           >= 0) qglUniform1iARB(p->loc_Texture_Shirt          , GL20TU_SHIRT);
1383                 if (p->loc_Texture_FogMask         >= 0) qglUniform1iARB(p->loc_Texture_FogMask        , GL20TU_FOGMASK);
1384                 if (p->loc_Texture_Lightmap        >= 0) qglUniform1iARB(p->loc_Texture_Lightmap       , GL20TU_LIGHTMAP);
1385                 if (p->loc_Texture_Deluxemap       >= 0) qglUniform1iARB(p->loc_Texture_Deluxemap      , GL20TU_DELUXEMAP);
1386                 if (p->loc_Texture_Attenuation     >= 0) qglUniform1iARB(p->loc_Texture_Attenuation    , GL20TU_ATTENUATION);
1387                 if (p->loc_Texture_Cube            >= 0) qglUniform1iARB(p->loc_Texture_Cube           , GL20TU_CUBE);
1388                 if (p->loc_Texture_Refraction      >= 0) qglUniform1iARB(p->loc_Texture_Refraction     , GL20TU_REFRACTION);
1389                 if (p->loc_Texture_Reflection      >= 0) qglUniform1iARB(p->loc_Texture_Reflection     , GL20TU_REFLECTION);
1390                 CHECKGLERROR
1391                 if (developer.integer)
1392                         Con_Printf("GLSL shader %s compiled.\n", permutationname);
1393         }
1394         else
1395                 Con_Printf("GLSL shader %s failed!  some features may not work properly.\n", permutationname);
1396
1397         // free the strings
1398         if (vertexstring)
1399                 Mem_Free(vertexstring);
1400         if (geometrystring)
1401                 Mem_Free(geometrystring);
1402         if (fragmentstring)
1403                 Mem_Free(fragmentstring);
1404 }
1405
1406 void R_GLSL_Restart_f(void)
1407 {
1408         shadermode_t mode;
1409         shaderpermutation_t permutation;
1410         for (mode = 0;mode < SHADERMODE_COUNT;mode++)
1411                 for (permutation = 0;permutation < SHADERPERMUTATION_LIMIT;permutation++)
1412                         if (r_glsl_permutations[mode][permutation].program)
1413                                 GL_Backend_FreeProgram(r_glsl_permutations[mode][permutation].program);
1414         memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
1415 }
1416
1417 void R_GLSL_DumpShader_f(void)
1418 {
1419         int i;
1420
1421         qfile_t *file = FS_Open("glsl/default.glsl", "w", false, false);
1422         if(!file)
1423         {
1424                 Con_Printf("failed to write to glsl/default.glsl\n");
1425                 return;
1426         }
1427
1428         FS_Print(file, "// The engine may define the following macros:\n");
1429         FS_Print(file, "// #define VERTEX_SHADER\n// #define GEOMETRY_SHADER\n// #define FRAGMENT_SHADER\n");
1430         for (i = 0;i < SHADERMODE_COUNT;i++)
1431                 FS_Printf(file, "// %s", shadermodeinfo[i].pretext);
1432         for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
1433                 FS_Printf(file, "// %s", shaderpermutationinfo[i].pretext);
1434         FS_Print(file, "\n");
1435         FS_Print(file, builtinshaderstring);
1436         FS_Close(file);
1437
1438         Con_Printf("glsl/default.glsl written\n");
1439 }
1440
1441 void R_SetupShader_SetPermutation(shadermode_t mode, unsigned int permutation)
1442 {
1443         r_glsl_permutation_t *perm = &r_glsl_permutations[mode][permutation];
1444         if (r_glsl_permutation != perm)
1445         {
1446                 r_glsl_permutation = perm;
1447                 if (!r_glsl_permutation->program)
1448                 {
1449                         if (!r_glsl_permutation->compiled)
1450                                 R_GLSL_CompilePermutation(mode, permutation);
1451                         if (!r_glsl_permutation->program)
1452                         {
1453                                 // remove features until we find a valid permutation
1454                                 int i;
1455                                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
1456                                 {
1457                                         // reduce i more quickly whenever it would not remove any bits
1458                                         int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
1459                                         if (!(permutation & j))
1460                                                 continue;
1461                                         permutation -= j;
1462                                         r_glsl_permutation = &r_glsl_permutations[mode][permutation];
1463                                         if (!r_glsl_permutation->compiled)
1464                                                 R_GLSL_CompilePermutation(mode, permutation);
1465                                         if (r_glsl_permutation->program)
1466                                                 break;
1467                                 }
1468                                 if (i >= SHADERPERMUTATION_COUNT)
1469                                 {
1470                                         Con_Printf("OpenGL 2.0 shaders disabled - unable to find a working shader permutation fallback on this driver (set r_glsl 1 if you want to try again)\n");
1471                                         Cvar_SetValueQuick(&r_glsl, 0);
1472                                         R_GLSL_Restart_f(); // unload shaders
1473                                         return; // no bit left to clear
1474                                 }
1475                         }
1476                 }
1477                 CHECKGLERROR
1478                 qglUseProgramObjectARB(r_glsl_permutation->program);CHECKGLERROR
1479         }
1480 }
1481
1482 void R_SetupGenericShader(qboolean usetexture)
1483 {
1484         if (gl_support_fragment_shader)
1485         {
1486                 if (r_glsl.integer && r_glsl_usegeneric.integer)
1487                         R_SetupShader_SetPermutation(SHADERMODE_GENERIC, usetexture ? SHADERPERMUTATION_DIFFUSE : 0);
1488                 else if (r_glsl_permutation)
1489                 {
1490                         r_glsl_permutation = NULL;
1491                         qglUseProgramObjectARB(0);CHECKGLERROR
1492                 }
1493         }
1494 }
1495
1496 void R_SetupGenericTwoTextureShader(int texturemode)
1497 {
1498         if (gl_support_fragment_shader)
1499         {
1500                 if (r_glsl.integer && r_glsl_usegeneric.integer)
1501                         R_SetupShader_SetPermutation(SHADERMODE_GENERIC, SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0))));
1502                 else if (r_glsl_permutation)
1503                 {
1504                         r_glsl_permutation = NULL;
1505                         qglUseProgramObjectARB(0);CHECKGLERROR
1506                 }
1507         }
1508         if (!r_glsl_permutation)
1509         {
1510                 if (texturemode == GL_DECAL && gl_combine.integer)
1511                         texturemode = GL_INTERPOLATE_ARB;
1512                 R_Mesh_TexCombine(1, texturemode, texturemode, 1, 1);
1513         }
1514 }
1515
1516 void R_SetupDepthOrShadowShader(void)
1517 {
1518         if (gl_support_fragment_shader)
1519         {
1520                 if (r_glsl.integer && r_glsl_usegeneric.integer)
1521                         R_SetupShader_SetPermutation(SHADERMODE_DEPTH_OR_SHADOW, 0);
1522                 else if (r_glsl_permutation)
1523                 {
1524                         r_glsl_permutation = NULL;
1525                         qglUseProgramObjectARB(0);CHECKGLERROR
1526                 }
1527         }
1528 }
1529
1530 extern rtexture_t *r_shadow_attenuationgradienttexture;
1531 extern rtexture_t *r_shadow_attenuation2dtexture;
1532 extern rtexture_t *r_shadow_attenuation3dtexture;
1533 void R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass)
1534 {
1535         // select a permutation of the lighting shader appropriate to this
1536         // combination of texture, entity, light source, and fogging, only use the
1537         // minimum features necessary to avoid wasting rendering time in the
1538         // fragment shader on features that are not being used
1539         unsigned int permutation = 0;
1540         shadermode_t mode = 0;
1541         // TODO: implement geometry-shader based shadow volumes someday
1542         if (r_glsl_offsetmapping.integer)
1543         {
1544                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
1545                 if (r_glsl_offsetmapping_reliefmapping.integer)
1546                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
1547         }
1548         if (rsurfacepass == RSURFPASS_BACKGROUND)
1549         {
1550                 // distorted background
1551                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
1552                         mode = SHADERMODE_WATER;
1553                 else
1554                         mode = SHADERMODE_REFRACTION;
1555         }
1556         else if (rsurfacepass == RSURFPASS_RTLIGHT)
1557         {
1558                 // light source
1559                 mode = SHADERMODE_LIGHTSOURCE;
1560                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
1561                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
1562                 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
1563                         permutation |= SHADERPERMUTATION_CUBEFILTER;
1564                 if (diffusescale > 0)
1565                         permutation |= SHADERPERMUTATION_DIFFUSE;
1566                 if (specularscale > 0)
1567                         permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
1568                 if (r_refdef.fogenabled)
1569                         permutation |= SHADERPERMUTATION_FOG;
1570                 if (rsurface.texture->colormapping)
1571                         permutation |= SHADERPERMUTATION_COLORMAPPING;
1572                 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1573                         permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1574         }
1575         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
1576         {
1577                 // unshaded geometry (fullbright or ambient model lighting)
1578                 mode = SHADERMODE_FLATCOLOR;
1579                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
1580                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
1581                 if (rsurface.texture->currentskinframe->glow && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
1582                         permutation |= SHADERPERMUTATION_GLOW;
1583                 if (r_refdef.fogenabled)
1584                         permutation |= SHADERPERMUTATION_FOG;
1585                 if (rsurface.texture->colormapping)
1586                         permutation |= SHADERPERMUTATION_COLORMAPPING;
1587                 if (r_glsl_offsetmapping.integer)
1588                 {
1589                         permutation |= SHADERPERMUTATION_OFFSETMAPPING;
1590                         if (r_glsl_offsetmapping_reliefmapping.integer)
1591                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
1592                 }
1593                 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1594                         permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1595                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1596                         permutation |= SHADERPERMUTATION_REFLECTION;
1597         }
1598         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT_DIRECTIONAL)
1599         {
1600                 // directional model lighting
1601                 mode = SHADERMODE_LIGHTDIRECTION;
1602                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
1603                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
1604                 if (rsurface.texture->currentskinframe->glow && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
1605                         permutation |= SHADERPERMUTATION_GLOW;
1606                 permutation |= SHADERPERMUTATION_DIFFUSE;
1607                 if (specularscale > 0)
1608                         permutation |= SHADERPERMUTATION_SPECULAR;
1609                 if (r_refdef.fogenabled)
1610                         permutation |= SHADERPERMUTATION_FOG;
1611                 if (rsurface.texture->colormapping)
1612                         permutation |= SHADERPERMUTATION_COLORMAPPING;
1613                 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1614                         permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1615                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1616                         permutation |= SHADERPERMUTATION_REFLECTION;
1617         }
1618         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
1619         {
1620                 // ambient model lighting
1621                 mode = SHADERMODE_LIGHTDIRECTION;
1622                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
1623                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
1624                 if (rsurface.texture->currentskinframe->glow && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
1625                         permutation |= SHADERPERMUTATION_GLOW;
1626                 if (r_refdef.fogenabled)
1627                         permutation |= SHADERPERMUTATION_FOG;
1628                 if (rsurface.texture->colormapping)
1629                         permutation |= SHADERPERMUTATION_COLORMAPPING;
1630                 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1631                         permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1632                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1633                         permutation |= SHADERPERMUTATION_REFLECTION;
1634         }
1635         else
1636         {
1637                 // lightmapped wall
1638                 if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping)
1639                 {
1640                         // deluxemapping (light direction texture)
1641                         if (rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping && r_refdef.scene.worldmodel->brushq3.deluxemapping_modelspace)
1642                                 mode = SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE;
1643                         else
1644                                 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
1645                         permutation |= SHADERPERMUTATION_DIFFUSE;
1646                         if (specularscale > 0)
1647                                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
1648                 }
1649                 else if (r_glsl_deluxemapping.integer >= 2)
1650                 {
1651                         // fake deluxemapping (uniform light direction in tangentspace)
1652                         mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
1653                         permutation |= SHADERPERMUTATION_DIFFUSE;
1654                         if (specularscale > 0)
1655                                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
1656                 }
1657                 else if (rsurface.uselightmaptexture)
1658                 {
1659                         // ordinary lightmapping (q1bsp, q3bsp)
1660                         mode = SHADERMODE_LIGHTMAP;
1661                 }
1662                 else
1663                 {
1664                         // ordinary vertex coloring (q3bsp)
1665                         mode = SHADERMODE_VERTEXCOLOR;
1666                 }
1667                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
1668                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
1669                 if (rsurface.texture->currentskinframe->glow && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
1670                         permutation |= SHADERPERMUTATION_GLOW;
1671                 if (r_refdef.fogenabled)
1672                         permutation |= SHADERPERMUTATION_FOG;
1673                 if (rsurface.texture->colormapping)
1674                         permutation |= SHADERPERMUTATION_COLORMAPPING;
1675                 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1676                         permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1677                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1678                         permutation |= SHADERPERMUTATION_REFLECTION;
1679         }
1680         R_SetupShader_SetPermutation(mode, permutation);
1681         if (mode == SHADERMODE_LIGHTSOURCE)
1682         {
1683                 if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
1684                 if (permutation & SHADERPERMUTATION_DIFFUSE)
1685                 {
1686                         if (r_glsl_permutation->loc_TintColor >= 0) qglUniform4fARB(r_glsl_permutation->loc_TintColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2], rsurface.texture->lightmapcolor[3]);
1687                         if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, ambientscale);
1688                         if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, diffusescale);
1689                         if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, specularscale);
1690                 }
1691                 else
1692                 {
1693                         // ambient only is simpler
1694                         if (r_glsl_permutation->loc_TintColor >= 0) qglUniform4fARB(r_glsl_permutation->loc_TintColor, lightcolorbase[0] * ambientscale, lightcolorbase[1] * ambientscale, lightcolorbase[2] * ambientscale, rsurface.texture->lightmapcolor[3]);
1695                         if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, 1);
1696                         if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, 0);
1697                         if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, 0);
1698                 }
1699                 // additive passes are only darkened by fog, not tinted
1700                 if (r_glsl_permutation->loc_FogColor >= 0)
1701                         qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
1702         }
1703         else
1704         {
1705                 if (mode == SHADERMODE_LIGHTDIRECTION)
1706                 {
1707                         if (r_glsl_permutation->loc_AmbientColor  >= 0) qglUniform3fARB(r_glsl_permutation->loc_AmbientColor , rsurface.modellight_ambient[0] * ambientscale  * 0.5f, rsurface.modellight_ambient[1] * ambientscale  * 0.5f, rsurface.modellight_ambient[2] * ambientscale  * 0.5f);
1708                         if (r_glsl_permutation->loc_DiffuseColor  >= 0) qglUniform3fARB(r_glsl_permutation->loc_DiffuseColor , rsurface.modellight_diffuse[0] * diffusescale  * 0.5f, rsurface.modellight_diffuse[1] * diffusescale  * 0.5f, rsurface.modellight_diffuse[2] * diffusescale  * 0.5f);
1709                         if (r_glsl_permutation->loc_SpecularColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_SpecularColor, rsurface.modellight_diffuse[0] * specularscale * 0.5f, rsurface.modellight_diffuse[1] * specularscale * 0.5f, rsurface.modellight_diffuse[2] * specularscale * 0.5f);
1710                         if (r_glsl_permutation->loc_LightDir      >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
1711                 }
1712                 else
1713                 {
1714                         if (r_glsl_permutation->loc_AmbientScale  >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, r_ambient.value * 1.0f / 128.0f);
1715                         if (r_glsl_permutation->loc_DiffuseScale  >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, r_refdef.lightmapintensity);
1716                         if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, r_refdef.lightmapintensity * specularscale);
1717                 }
1718                 if (r_glsl_permutation->loc_TintColor >= 0) qglUniform4fARB(r_glsl_permutation->loc_TintColor, rsurface.texture->lightmapcolor[0], rsurface.texture->lightmapcolor[1], rsurface.texture->lightmapcolor[2], rsurface.texture->lightmapcolor[3]);
1719                 if (r_glsl_permutation->loc_GlowScale     >= 0) qglUniform1fARB(r_glsl_permutation->loc_GlowScale, r_hdr_glowintensity.value);
1720                 // additive passes are only darkened by fog, not tinted
1721                 if (r_glsl_permutation->loc_FogColor >= 0)
1722                 {
1723                         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
1724                                 qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
1725                         else
1726                                 qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
1727                 }
1728                 if (r_glsl_permutation->loc_DistortScaleRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_DistortScaleRefractReflect, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor);
1729                 if (r_glsl_permutation->loc_ScreenScaleRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_ScreenScaleRefractReflect, r_waterstate.screenscale[0], r_waterstate.screenscale[1], r_waterstate.screenscale[0], r_waterstate.screenscale[1]);
1730                 if (r_glsl_permutation->loc_ScreenCenterRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_ScreenCenterRefractReflect, r_waterstate.screencenter[0], r_waterstate.screencenter[1], r_waterstate.screencenter[0], r_waterstate.screencenter[1]);
1731                 if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_RefractColor, 1, rsurface.texture->refractcolor4f);
1732                 if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_ReflectColor, 1, rsurface.texture->reflectcolor4f);
1733                 if (r_glsl_permutation->loc_ReflectFactor >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
1734                 if (r_glsl_permutation->loc_ReflectOffset >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectOffset, rsurface.texture->reflectmin);
1735         }
1736         if (r_glsl_permutation->loc_ContrastBoostCoeff >= 0)
1737         {
1738                 // The formula used is actually:
1739                 //   color.rgb *= ContrastBoost / ((ContrastBoost - 1) * color.rgb + 1);
1740                 //   color.rgb *= SceneBrightness;
1741                 // simplified:
1742                 //   color.rgb = [[SceneBrightness * ContrastBoost]] * color.rgb / ([[ContrastBoost - 1]] * color.rgb + 1);
1743                 // and do [[calculations]] here in the engine
1744                 qglUniform1fARB(r_glsl_permutation->loc_ContrastBoostCoeff, r_glsl_contrastboost.value - 1);
1745                 if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_refdef.view.colorscale * r_glsl_contrastboost.value);
1746         }
1747         else
1748                 if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_refdef.view.colorscale);
1749         if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.modelorg[0], rsurface.modelorg[1], rsurface.modelorg[2]);
1750         if (r_glsl_permutation->loc_Color_Pants >= 0)
1751         {
1752                 if (rsurface.texture->currentskinframe->pants)
1753                         qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
1754                 else
1755                         qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, 0, 0, 0);
1756         }
1757         if (r_glsl_permutation->loc_Color_Shirt >= 0)
1758         {
1759                 if (rsurface.texture->currentskinframe->shirt)
1760                         qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
1761                 else
1762                         qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
1763         }
1764         if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, r_refdef.fograngerecip);
1765         if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower);
1766         if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);
1767         CHECKGLERROR
1768 }
1769
1770 #define SKINFRAME_HASH 1024
1771
1772 struct
1773 {
1774         int loadsequence; // incremented each level change
1775         memexpandablearray_t array;
1776         skinframe_t *hash[SKINFRAME_HASH];
1777 }
1778 r_skinframe;
1779
1780 void R_SkinFrame_PrepareForPurge(void)
1781 {
1782         r_skinframe.loadsequence++;
1783         // wrap it without hitting zero
1784         if (r_skinframe.loadsequence >= 200)
1785                 r_skinframe.loadsequence = 1;
1786 }
1787
1788 void R_SkinFrame_MarkUsed(skinframe_t *skinframe)
1789 {
1790         if (!skinframe)
1791                 return;
1792         // mark the skinframe as used for the purging code
1793         skinframe->loadsequence = r_skinframe.loadsequence;
1794 }
1795
1796 void R_SkinFrame_Purge(void)
1797 {
1798         int i;
1799         skinframe_t *s;
1800         for (i = 0;i < SKINFRAME_HASH;i++)
1801         {
1802                 for (s = r_skinframe.hash[i];s;s = s->next)
1803                 {
1804                         if (s->loadsequence && s->loadsequence != r_skinframe.loadsequence)
1805                         {
1806                                 if (s->merged == s->base)
1807                                         s->merged = NULL;
1808                                 // FIXME: maybe pass a pointer to the pointer to R_PurgeTexture and reset it to NULL inside? [11/29/2007 Black]
1809                                 R_PurgeTexture(s->stain );s->stain  = NULL;
1810                                 R_PurgeTexture(s->merged);s->merged = NULL;
1811                                 R_PurgeTexture(s->base  );s->base   = NULL;
1812                                 R_PurgeTexture(s->pants );s->pants  = NULL;
1813                                 R_PurgeTexture(s->shirt );s->shirt  = NULL;
1814                                 R_PurgeTexture(s->nmap  );s->nmap   = NULL;
1815                                 R_PurgeTexture(s->gloss );s->gloss  = NULL;
1816                                 R_PurgeTexture(s->glow  );s->glow   = NULL;
1817                                 R_PurgeTexture(s->fog   );s->fog    = NULL;
1818                                 s->loadsequence = 0;
1819                         }
1820                 }
1821         }
1822 }
1823
1824 skinframe_t *R_SkinFrame_FindNextByName( skinframe_t *last, const char *name ) {
1825         skinframe_t *item;
1826         char basename[MAX_QPATH];
1827
1828         Image_StripImageExtension(name, basename, sizeof(basename));
1829
1830         if( last == NULL ) {
1831                 int hashindex;
1832                 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
1833                 item = r_skinframe.hash[hashindex];
1834         } else {
1835                 item = last->next;
1836         }
1837
1838         // linearly search through the hash bucket
1839         for( ; item ; item = item->next ) {
1840                 if( !strcmp( item->basename, basename ) ) {
1841                         return item;
1842                 }
1843         }
1844         return NULL;
1845 }
1846
1847 skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qboolean add)
1848 {
1849         skinframe_t *item;
1850         int hashindex;
1851         char basename[MAX_QPATH];
1852
1853         Image_StripImageExtension(name, basename, sizeof(basename));
1854
1855         hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
1856         for (item = r_skinframe.hash[hashindex];item;item = item->next)
1857                 if (!strcmp(item->basename, basename) && item->textureflags == textureflags && item->comparewidth == comparewidth && item->compareheight == compareheight && item->comparecrc == comparecrc)
1858                         break;
1859
1860         if (!item) {
1861                 rtexture_t *dyntexture;
1862                 // check whether its a dynamic texture
1863                 dyntexture = CL_GetDynTexture( basename );
1864                 if (!add && !dyntexture)
1865                         return NULL;
1866                 item = (skinframe_t *)Mem_ExpandableArray_AllocRecord(&r_skinframe.array);
1867                 memset(item, 0, sizeof(*item));
1868                 strlcpy(item->basename, basename, sizeof(item->basename));
1869                 item->base = dyntexture; // either NULL or dyntexture handle
1870                 item->textureflags = textureflags;
1871                 item->comparewidth = comparewidth;
1872                 item->compareheight = compareheight;
1873                 item->comparecrc = comparecrc;
1874                 item->next = r_skinframe.hash[hashindex];
1875                 r_skinframe.hash[hashindex] = item;
1876         }
1877         else if( item->base == NULL )
1878         {
1879                 rtexture_t *dyntexture;
1880                 // check whether its a dynamic texture
1881                 // this only needs to be done because Purge doesnt delete skinframes - only sets the texture pointers to NULL and we need to restore it before returing.. [11/29/2007 Black]
1882                 dyntexture = CL_GetDynTexture( basename );
1883                 item->base = dyntexture; // either NULL or dyntexture handle
1884         }
1885
1886         R_SkinFrame_MarkUsed(item);
1887         return item;
1888 }
1889
1890 skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain)
1891 {
1892         // FIXME: it should be possible to disable loading various layers using
1893         // cvars, to prevent wasted loading time and memory usage if the user does
1894         // not want them
1895         qboolean loadnormalmap = true;
1896         qboolean loadgloss = true;
1897         qboolean loadpantsandshirt = true;
1898         qboolean loadglow = true;
1899         int j;
1900         unsigned char *pixels;
1901         unsigned char *bumppixels;
1902         unsigned char *basepixels = NULL;
1903         int basepixels_width;
1904         int basepixels_height;
1905         skinframe_t *skinframe;
1906
1907         if (cls.state == ca_dedicated)
1908                 return NULL;
1909
1910         // return an existing skinframe if already loaded
1911         // if loading of the first image fails, don't make a new skinframe as it
1912         // would cause all future lookups of this to be missing
1913         skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
1914         if (skinframe && skinframe->base)
1915                 return skinframe;
1916
1917         basepixels = loadimagepixelsbgra(name, complain, true);
1918         if (basepixels == NULL)
1919                 return NULL;
1920
1921         // we've got some pixels to store, so really allocate this new texture now
1922         if (!skinframe)
1923                 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, true);
1924         skinframe->stain = NULL;
1925         skinframe->merged = NULL;
1926         skinframe->base = r_texture_notexture;
1927         skinframe->pants = NULL;
1928         skinframe->shirt = NULL;
1929         skinframe->nmap = r_texture_blanknormalmap;
1930         skinframe->gloss = NULL;
1931         skinframe->glow = NULL;
1932         skinframe->fog = NULL;
1933
1934         basepixels_width = image_width;
1935         basepixels_height = image_height;
1936         skinframe->base = R_LoadTexture2D (r_main_texturepool, skinframe->basename, basepixels_width, basepixels_height, basepixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);
1937
1938         if (textureflags & TEXF_ALPHA)
1939         {
1940                 for (j = 3;j < basepixels_width * basepixels_height * 4;j += 4)
1941                         if (basepixels[j] < 255)
1942                                 break;
1943                 if (j < basepixels_width * basepixels_height * 4)
1944                 {
1945                         // has transparent pixels
1946                         pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
1947                         for (j = 0;j < image_width * image_height * 4;j += 4)
1948                         {
1949                                 pixels[j+0] = 255;
1950                                 pixels[j+1] = 255;
1951                                 pixels[j+2] = 255;
1952                                 pixels[j+3] = basepixels[j+3];
1953                         }
1954                         skinframe->fog = R_LoadTexture2D (r_main_texturepool, va("%s_mask", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);
1955                         Mem_Free(pixels);
1956                 }
1957         }
1958
1959         // _norm is the name used by tenebrae and has been adopted as standard
1960         if (loadnormalmap)
1961         {
1962                 if ((pixels = loadimagepixelsbgra(va("%s_norm", skinframe->basename), false, false)) != NULL)
1963                 {
1964                         skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
1965                         Mem_Free(pixels);
1966                         pixels = NULL;
1967                 }
1968                 else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixelsbgra(va("%s_bump", skinframe->basename), false, false)) != NULL)
1969                 {
1970                         pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
1971                         Image_HeightmapToNormalmap_BGRA(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value);
1972                         skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
1973                         Mem_Free(pixels);
1974                         Mem_Free(bumppixels);
1975                 }
1976                 else if (r_shadow_bumpscale_basetexture.value > 0)
1977                 {
1978                         pixels = (unsigned char *)Mem_Alloc(tempmempool, basepixels_width * basepixels_height * 4);
1979                         Image_HeightmapToNormalmap_BGRA(basepixels, pixels, basepixels_width, basepixels_height, false, r_shadow_bumpscale_basetexture.value);
1980                         skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), basepixels_width, basepixels_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
1981                         Mem_Free(pixels);
1982                 }
1983         }
1984         // _luma is supported for tenebrae compatibility
1985         // (I think it's a very stupid name, but oh well)
1986         // _glow is the preferred name
1987         if (loadglow          && ((pixels = loadimagepixelsbgra(va("%s_glow", skinframe->basename), false, false)) != NULL || (pixels = loadimagepixelsbgra(va("%s_luma", skinframe->basename), false, false)) != NULL)) {skinframe->glow = R_LoadTexture2D (r_main_texturepool, va("%s_glow", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_glow.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
1988         if (loadgloss         && (pixels = loadimagepixelsbgra(va("%s_gloss", skinframe->basename), false, false)) != NULL) {skinframe->gloss = R_LoadTexture2D (r_main_texturepool, va("%s_gloss", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_gloss.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
1989         if (loadpantsandshirt && (pixels = loadimagepixelsbgra(va("%s_pants", skinframe->basename), false, false)) != NULL) {skinframe->pants = R_LoadTexture2D (r_main_texturepool, va("%s_pants", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
1990         if (loadpantsandshirt && (pixels = loadimagepixelsbgra(va("%s_shirt", skinframe->basename), false, false)) != NULL) {skinframe->shirt = R_LoadTexture2D (r_main_texturepool, va("%s_shirt", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
1991
1992         if (basepixels)
1993                 Mem_Free(basepixels);
1994
1995         return skinframe;
1996 }
1997
1998 static rtexture_t *R_SkinFrame_TextureForSkinLayer(const unsigned char *in, int width, int height, const char *name, const unsigned int *palette, int textureflags, qboolean force)
1999 {
2000         int i;
2001         if (!force)
2002         {
2003                 for (i = 0;i < width*height;i++)
2004                         if (((unsigned char *)&palette[in[i]])[3] > 0)
2005                                 break;
2006                 if (i == width*height)
2007                         return NULL;
2008         }
2009         return R_LoadTexture2D (r_main_texturepool, name, width, height, in, TEXTYPE_PALETTE, textureflags, palette);
2010 }
2011
2012 // this is only used by .spr32 sprites, HL .spr files, HL .bsp files
2013 skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, const unsigned char *skindata, int width, int height)
2014 {
2015         int i;
2016         unsigned char *temp1, *temp2;
2017         skinframe_t *skinframe;
2018
2019         if (cls.state == ca_dedicated)
2020                 return NULL;
2021
2022         // if already loaded just return it, otherwise make a new skinframe
2023         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height*4) : 0, true);
2024         if (skinframe && skinframe->base)
2025                 return skinframe;
2026
2027         skinframe->stain = NULL;
2028         skinframe->merged = NULL;
2029         skinframe->base = r_texture_notexture;
2030         skinframe->pants = NULL;
2031         skinframe->shirt = NULL;
2032         skinframe->nmap = r_texture_blanknormalmap;
2033         skinframe->gloss = NULL;
2034         skinframe->glow = NULL;
2035         skinframe->fog = NULL;
2036
2037         // if no data was provided, then clearly the caller wanted to get a blank skinframe
2038         if (!skindata)
2039                 return NULL;
2040
2041         if (r_shadow_bumpscale_basetexture.value > 0)
2042         {
2043                 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
2044                 temp2 = temp1 + width * height * 4;
2045                 Image_HeightmapToNormalmap_BGRA(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
2046                 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, NULL);
2047                 Mem_Free(temp1);
2048         }
2049         skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_BGRA, skinframe->textureflags, NULL);
2050         if (textureflags & TEXF_ALPHA)
2051         {
2052                 for (i = 3;i < width * height * 4;i += 4)
2053                         if (skindata[i] < 255)
2054                                 break;
2055                 if (i < width * height * 4)
2056                 {
2057                         unsigned char *fogpixels = (unsigned char *)Mem_Alloc(tempmempool, width * height * 4);
2058                         memcpy(fogpixels, skindata, width * height * 4);
2059                         for (i = 0;i < width * height * 4;i += 4)
2060                                 fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
2061                         skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_BGRA, skinframe->textureflags, NULL);
2062                         Mem_Free(fogpixels);
2063                 }
2064         }
2065
2066         return skinframe;
2067 }
2068
2069 skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height)
2070 {
2071         int i;
2072         unsigned char *temp1, *temp2;
2073         skinframe_t *skinframe;
2074
2075         if (cls.state == ca_dedicated)
2076                 return NULL;
2077
2078         // if already loaded just return it, otherwise make a new skinframe
2079         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
2080         if (skinframe && skinframe->base)
2081                 return skinframe;
2082
2083         skinframe->stain = NULL;
2084         skinframe->merged = NULL;
2085         skinframe->base = r_texture_notexture;
2086         skinframe->pants = NULL;
2087         skinframe->shirt = NULL;
2088         skinframe->nmap = r_texture_blanknormalmap;
2089         skinframe->gloss = NULL;
2090         skinframe->glow = NULL;
2091         skinframe->fog = NULL;
2092
2093         // if no data was provided, then clearly the caller wanted to get a blank skinframe
2094         if (!skindata)
2095                 return NULL;
2096
2097         if (r_shadow_bumpscale_basetexture.value > 0)
2098         {
2099                 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
2100                 temp2 = temp1 + width * height * 4;
2101                 // use either a custom palette or the quake palette
2102                 Image_Copy8bitBGRA(skindata, temp1, width * height, palette_bgra_complete);
2103                 Image_HeightmapToNormalmap_BGRA(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
2104                 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, NULL);
2105                 Mem_Free(temp1);
2106         }
2107         // use either a custom palette, or the quake palette
2108         skinframe->base = skinframe->merged = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_merged", skinframe->basename), (loadglowtexture ? palette_bgra_nofullbrights : ((skinframe->textureflags & TEXF_ALPHA) ? palette_bgra_transparent : palette_bgra_complete)), skinframe->textureflags, true); // all
2109         if (loadglowtexture)
2110                 skinframe->glow = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_glow", skinframe->basename), palette_bgra_onlyfullbrights, skinframe->textureflags, false); // glow
2111         if (loadpantsandshirt)
2112         {
2113                 skinframe->pants = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_pants", skinframe->basename), palette_bgra_pantsaswhite, skinframe->textureflags, false); // pants
2114                 skinframe->shirt = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_shirt", skinframe->basename), palette_bgra_shirtaswhite, skinframe->textureflags, false); // shirt
2115         }
2116         if (skinframe->pants || skinframe->shirt)
2117                 skinframe->base = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_nospecial", skinframe->basename), loadglowtexture ? palette_bgra_nocolormapnofullbrights : palette_bgra_nocolormap, skinframe->textureflags, false); // no special colors
2118         if (textureflags & TEXF_ALPHA)
2119         {
2120                 for (i = 0;i < width * height;i++)
2121                         if (((unsigned char *)palette_bgra_alpha)[skindata[i]*4+3] < 255)
2122                                 break;
2123                 if (i < width * height)
2124                         skinframe->fog = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_fog", skinframe->basename), palette_bgra_alpha, skinframe->textureflags, true); // fog mask
2125         }
2126
2127         return skinframe;
2128 }
2129
2130 skinframe_t *R_SkinFrame_LoadMissing(void)
2131 {
2132         skinframe_t *skinframe;
2133
2134         if (cls.state == ca_dedicated)
2135                 return NULL;
2136
2137         skinframe = R_SkinFrame_Find("missing", TEXF_PRECACHE, 0, 0, 0, true);
2138         skinframe->stain = NULL;
2139         skinframe->merged = NULL;
2140         skinframe->base = r_texture_notexture;
2141         skinframe->pants = NULL;
2142         skinframe->shirt = NULL;
2143         skinframe->nmap = r_texture_blanknormalmap;
2144         skinframe->gloss = NULL;
2145         skinframe->glow = NULL;
2146         skinframe->fog = NULL;
2147
2148         return skinframe;
2149 }
2150
2151 void gl_main_start(void)
2152 {
2153         memset(r_qwskincache, 0, sizeof(r_qwskincache));
2154         memset(r_qwskincache_skinframe, 0, sizeof(r_qwskincache_skinframe));
2155
2156         // set up r_skinframe loading system for textures
2157         memset(&r_skinframe, 0, sizeof(r_skinframe));
2158         r_skinframe.loadsequence = 1;
2159         Mem_ExpandableArray_NewArray(&r_skinframe.array, r_main_mempool, sizeof(skinframe_t), 256);
2160
2161         r_main_texturepool = R_AllocTexturePool();
2162         R_BuildBlankTextures();
2163         R_BuildNoTexture();
2164         if (gl_texturecubemap)
2165         {
2166                 R_BuildWhiteCube();
2167                 R_BuildNormalizationCube();
2168         }
2169         r_texture_fogattenuation = NULL;
2170         //r_texture_fogintensity = NULL;
2171         memset(&r_bloomstate, 0, sizeof(r_bloomstate));
2172         memset(&r_waterstate, 0, sizeof(r_waterstate));
2173         memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
2174         memset(&r_svbsp, 0, sizeof (r_svbsp));
2175
2176         r_refdef.fogmasktable_density = 0;
2177 }
2178
2179 void gl_main_shutdown(void)
2180 {
2181         memset(r_qwskincache, 0, sizeof(r_qwskincache));
2182         memset(r_qwskincache_skinframe, 0, sizeof(r_qwskincache_skinframe));
2183
2184         // clear out the r_skinframe state
2185         Mem_ExpandableArray_FreeArray(&r_skinframe.array);
2186         memset(&r_skinframe, 0, sizeof(r_skinframe));
2187
2188         if (r_svbsp.nodes)
2189                 Mem_Free(r_svbsp.nodes);
2190         memset(&r_svbsp, 0, sizeof (r_svbsp));
2191         R_FreeTexturePool(&r_main_texturepool);
2192         r_texture_blanknormalmap = NULL;
2193         r_texture_white = NULL;
2194         r_texture_grey128 = NULL;
2195         r_texture_black = NULL;
2196         r_texture_whitecube = NULL;
2197         r_texture_normalizationcube = NULL;
2198         r_texture_fogattenuation = NULL;
2199         //r_texture_fogintensity = NULL;
2200         memset(&r_bloomstate, 0, sizeof(r_bloomstate));
2201         memset(&r_waterstate, 0, sizeof(r_waterstate));
2202         R_GLSL_Restart_f();
2203 }
2204
2205 extern void CL_ParseEntityLump(char *entitystring);
2206 void gl_main_newmap(void)
2207 {
2208         // FIXME: move this code to client
2209         int l;
2210         char *entities, entname[MAX_QPATH];
2211         if (cl.worldmodel)
2212         {
2213                 strlcpy(entname, cl.worldmodel->name, sizeof(entname));
2214                 l = (int)strlen(entname) - 4;
2215                 if (l >= 0 && !strcmp(entname + l, ".bsp"))
2216                 {
2217                         memcpy(entname + l, ".ent", 5);
2218                         if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
2219                         {
2220                                 CL_ParseEntityLump(entities);
2221                                 Mem_Free(entities);
2222                                 return;
2223                         }
2224                 }
2225                 if (cl.worldmodel->brush.entities)
2226                         CL_ParseEntityLump(cl.worldmodel->brush.entities);
2227         }
2228 }
2229
2230 void GL_Main_Init(void)
2231 {
2232         r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
2233
2234         Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed");
2235         Cmd_AddCommand("r_glsl_dumpshader", R_GLSL_DumpShader_f, "dumps the engine internal default.glsl shader into glsl/default.glsl");
2236         // FIXME: the client should set up r_refdef.fog stuff including the fogmasktable
2237         if (gamemode == GAME_NEHAHRA)
2238         {
2239                 Cvar_RegisterVariable (&gl_fogenable);
2240                 Cvar_RegisterVariable (&gl_fogdensity);
2241                 Cvar_RegisterVariable (&gl_fogred);
2242                 Cvar_RegisterVariable (&gl_foggreen);
2243                 Cvar_RegisterVariable (&gl_fogblue);
2244                 Cvar_RegisterVariable (&gl_fogstart);
2245                 Cvar_RegisterVariable (&gl_fogend);
2246                 Cvar_RegisterVariable (&gl_skyclip);
2247         }
2248         Cvar_RegisterVariable(&r_depthfirst);
2249         Cvar_RegisterVariable(&r_nearclip);
2250         Cvar_RegisterVariable(&r_showbboxes);
2251         Cvar_RegisterVariable(&r_showsurfaces);
2252         Cvar_RegisterVariable(&r_showtris);
2253         Cvar_RegisterVariable(&r_shownormals);
2254         Cvar_RegisterVariable(&r_showlighting);
2255         Cvar_RegisterVariable(&r_showshadowvolumes);
2256         Cvar_RegisterVariable(&r_showcollisionbrushes);
2257         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
2258         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
2259         Cvar_RegisterVariable(&r_showdisabledepthtest);
2260         Cvar_RegisterVariable(&r_drawportals);
2261         Cvar_RegisterVariable(&r_drawentities);
2262         Cvar_RegisterVariable(&r_cullentities_trace);
2263         Cvar_RegisterVariable(&r_cullentities_trace_samples);
2264         Cvar_RegisterVariable(&r_cullentities_trace_enlarge);
2265         Cvar_RegisterVariable(&r_cullentities_trace_delay);
2266         Cvar_RegisterVariable(&r_drawviewmodel);
2267         Cvar_RegisterVariable(&r_speeds);
2268         Cvar_RegisterVariable(&r_fullbrights);
2269         Cvar_RegisterVariable(&r_wateralpha);
2270         Cvar_RegisterVariable(&r_dynamic);
2271         Cvar_RegisterVariable(&r_fullbright);
2272         Cvar_RegisterVariable(&r_shadows);
2273         Cvar_RegisterVariable(&r_shadows_throwdistance);
2274         Cvar_RegisterVariable(&r_q1bsp_skymasking);
2275         Cvar_RegisterVariable(&r_polygonoffset_submodel_factor);
2276         Cvar_RegisterVariable(&r_polygonoffset_submodel_offset);
2277         Cvar_RegisterVariable(&r_fog_exp2);
2278         Cvar_RegisterVariable(&r_textureunits);
2279         Cvar_RegisterVariable(&r_glsl);
2280         Cvar_RegisterVariable(&r_glsl_contrastboost);
2281         Cvar_RegisterVariable(&r_glsl_deluxemapping);
2282         Cvar_RegisterVariable(&r_glsl_offsetmapping);
2283         Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
2284         Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
2285         Cvar_RegisterVariable(&r_glsl_postprocess);
2286         Cvar_RegisterVariable(&r_glsl_postprocess_contrastboost);
2287         Cvar_RegisterVariable(&r_glsl_postprocess_gamma);
2288         Cvar_RegisterVariable(&r_glsl_postprocess_uservec1);
2289         Cvar_RegisterVariable(&r_glsl_postprocess_uservec2);
2290         Cvar_RegisterVariable(&r_glsl_postprocess_uservec3);
2291         Cvar_RegisterVariable(&r_glsl_postprocess_uservec4);
2292         Cvar_RegisterVariable(&r_glsl_usegeneric);
2293         Cvar_RegisterVariable(&r_water);
2294         Cvar_RegisterVariable(&r_water_resolutionmultiplier);
2295         Cvar_RegisterVariable(&r_water_clippingplanebias);
2296         Cvar_RegisterVariable(&r_water_refractdistort);
2297         Cvar_RegisterVariable(&r_water_reflectdistort);
2298         Cvar_RegisterVariable(&r_lerpsprites);
2299         Cvar_RegisterVariable(&r_lerpmodels);
2300         Cvar_RegisterVariable(&r_lerplightstyles);
2301         Cvar_RegisterVariable(&r_waterscroll);
2302         Cvar_RegisterVariable(&r_bloom);
2303         Cvar_RegisterVariable(&r_bloom_colorscale);
2304         Cvar_RegisterVariable(&r_bloom_brighten);
2305         Cvar_RegisterVariable(&r_bloom_blur);
2306         Cvar_RegisterVariable(&r_bloom_resolution);
2307         Cvar_RegisterVariable(&r_bloom_colorexponent);
2308         Cvar_RegisterVariable(&r_bloom_colorsubtract);
2309         Cvar_RegisterVariable(&r_hdr);
2310         Cvar_RegisterVariable(&r_hdr_scenebrightness);
2311         Cvar_RegisterVariable(&r_hdr_glowintensity);
2312         Cvar_RegisterVariable(&r_hdr_range);
2313         Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
2314         Cvar_RegisterVariable(&developer_texturelogging);
2315         Cvar_RegisterVariable(&gl_lightmaps);
2316         Cvar_RegisterVariable(&r_test);
2317         Cvar_RegisterVariable(&r_batchmode);
2318         if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
2319                 Cvar_SetValue("r_fullbrights", 0);
2320         R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap);
2321
2322         Cvar_RegisterVariable(&r_track_sprites);
2323         Cvar_RegisterVariable(&r_track_sprites_flags);
2324         Cvar_RegisterVariable(&r_track_sprites_scalew);
2325         Cvar_RegisterVariable(&r_track_sprites_scaleh);
2326 }
2327
2328 extern void R_Textures_Init(void);
2329 extern void GL_Draw_Init(void);
2330 extern void GL_Main_Init(void);
2331 extern void R_Shadow_Init(void);
2332 extern void R_Sky_Init(void);
2333 extern void GL_Surf_Init(void);
2334 extern void R_Particles_Init(void);
2335 extern void R_Explosion_Init(void);
2336 extern void gl_backend_init(void);
2337 extern void Sbar_Init(void);
2338 extern void R_LightningBeams_Init(void);
2339 extern void Mod_RenderInit(void);
2340
2341 void Render_Init(void)
2342 {
2343         gl_backend_init();
2344         R_Textures_Init();
2345         GL_Main_Init();
2346         GL_Draw_Init();
2347         R_Shadow_Init();
2348         R_Sky_Init();
2349         GL_Surf_Init();
2350         Sbar_Init();
2351         R_Particles_Init();
2352         R_Explosion_Init();
2353         R_LightningBeams_Init();
2354         Mod_RenderInit();
2355 }
2356
2357 /*
2358 ===============
2359 GL_Init
2360 ===============
2361 */
2362 extern char *ENGINE_EXTENSIONS;
2363 void GL_Init (void)
2364 {
2365         VID_CheckExtensions();
2366
2367         // LordHavoc: report supported extensions
2368         Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
2369
2370         // clear to black (loading plaque will be seen over this)
2371         CHECKGLERROR
2372         qglClearColor(0,0,0,1);CHECKGLERROR
2373         qglClear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
2374 }
2375
2376 int R_CullBox(const vec3_t mins, const vec3_t maxs)
2377 {
2378         int i;
2379         mplane_t *p;
2380         for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
2381         {
2382                 // skip nearclip plane, it often culls portals when you are very close, and is almost never useful
2383                 if (i == 4)
2384                         continue;
2385                 p = r_refdef.view.frustum + i;
2386                 switch(p->signbits)
2387                 {
2388                 default:
2389                 case 0:
2390                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2391                                 return true;
2392                         break;
2393                 case 1:
2394                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2395                                 return true;
2396                         break;
2397                 case 2:
2398                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2399                                 return true;
2400                         break;
2401                 case 3:
2402                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2403                                 return true;
2404                         break;
2405                 case 4:
2406                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2407                                 return true;
2408                         break;
2409                 case 5:
2410                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2411                                 return true;
2412                         break;
2413                 case 6:
2414                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2415                                 return true;
2416                         break;
2417                 case 7:
2418                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2419                                 return true;
2420                         break;
2421                 }
2422         }
2423         return false;
2424 }
2425
2426 int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes)
2427 {
2428         int i;
2429         const mplane_t *p;
2430         for (i = 0;i < numplanes;i++)
2431         {
2432                 p = planes + i;
2433                 switch(p->signbits)
2434                 {
2435                 default:
2436                 case 0:
2437                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2438                                 return true;
2439                         break;
2440                 case 1:
2441                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2442                                 return true;
2443                         break;
2444                 case 2:
2445                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2446                                 return true;
2447                         break;
2448                 case 3:
2449                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2450                                 return true;
2451                         break;
2452                 case 4:
2453                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2454                                 return true;
2455                         break;
2456                 case 5:
2457                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2458                                 return true;
2459                         break;
2460                 case 6:
2461                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2462                                 return true;
2463                         break;
2464                 case 7:
2465                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2466                                 return true;
2467                         break;
2468                 }
2469         }
2470         return false;
2471 }
2472
2473 //==================================================================================
2474
2475 static void R_View_UpdateEntityVisible (void)
2476 {
2477         int i, renderimask;
2478         entity_render_t *ent;
2479
2480         if (!r_drawentities.integer)
2481                 return;
2482
2483         renderimask = r_refdef.envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL) : ((chase_active.integer || r_waterstate.renderingscene) ? RENDER_VIEWMODEL : RENDER_EXTERIORMODEL);
2484         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs)
2485         {
2486                 // worldmodel can check visibility
2487                 for (i = 0;i < r_refdef.scene.numentities;i++)
2488                 {
2489                         ent = r_refdef.scene.entities[i];
2490                         r_refdef.viewcache.entityvisible[i] = !(ent->flags & renderimask) && ((ent->model && ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE)) || !R_CullBox(ent->mins, ent->maxs)) && ((ent->effects & EF_NODEPTHTEST) || (ent->flags & RENDER_VIEWMODEL) || r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.scene.worldmodel, r_refdef.viewcache.world_leafvisible, ent->mins, ent->maxs));
2491
2492                 }
2493                 if(r_cullentities_trace.integer && r_refdef.scene.worldmodel->brush.TraceLineOfSight)
2494                 {
2495                         for (i = 0;i < r_refdef.scene.numentities;i++)
2496                         {
2497                                 ent = r_refdef.scene.entities[i];
2498                                 if(r_refdef.viewcache.entityvisible[i] && !(ent->effects & EF_NODEPTHTEST) && !(ent->flags & RENDER_VIEWMODEL) && !(ent->model && (ent->model->name[0] == '*')))
2499                                 {
2500                                         if(Mod_CanSeeBox_Trace(r_cullentities_trace_samples.integer, r_cullentities_trace_enlarge.value, r_refdef.scene.worldmodel, r_refdef.view.origin, ent->mins, ent->maxs))
2501                                                 ent->last_trace_visibility = realtime;
2502                                         if(ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value)
2503                                                 r_refdef.viewcache.entityvisible[i] = 0;
2504                                 }
2505                         }
2506                 }
2507         }
2508         else
2509         {
2510                 // no worldmodel or it can't check visibility
2511                 for (i = 0;i < r_refdef.scene.numentities;i++)
2512                 {
2513                         ent = r_refdef.scene.entities[i];
2514                         r_refdef.viewcache.entityvisible[i] = !(ent->flags & renderimask) && ((ent->model && ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE)) || !R_CullBox(ent->mins, ent->maxs));
2515                 }
2516         }
2517 }
2518
2519 // only used if skyrendermasked, and normally returns false
2520 int R_DrawBrushModelsSky (void)
2521 {
2522         int i, sky;
2523         entity_render_t *ent;
2524
2525         if (!r_drawentities.integer)
2526                 return false;
2527
2528         sky = false;
2529         for (i = 0;i < r_refdef.scene.numentities;i++)
2530         {
2531                 if (!r_refdef.viewcache.entityvisible[i])
2532                         continue;
2533                 ent = r_refdef.scene.entities[i];
2534                 if (!ent->model || !ent->model->DrawSky)
2535                         continue;
2536                 ent->model->DrawSky(ent);
2537                 sky = true;
2538         }
2539         return sky;
2540 }
2541
2542 static void R_DrawNoModel(entity_render_t *ent);
2543 static void R_DrawModels(void)
2544 {
2545         int i;
2546         entity_render_t *ent;
2547
2548         if (!r_drawentities.integer)
2549                 return;
2550
2551         for (i = 0;i < r_refdef.scene.numentities;i++)
2552         {
2553                 if (!r_refdef.viewcache.entityvisible[i])
2554                         continue;
2555                 ent = r_refdef.scene.entities[i];
2556                 r_refdef.stats.entities++;
2557                 if (ent->model && ent->model->Draw != NULL)
2558                         ent->model->Draw(ent);
2559                 else
2560                         R_DrawNoModel(ent);
2561         }
2562 }
2563
2564 static void R_DrawModelsDepth(void)
2565 {
2566         int i;
2567         entity_render_t *ent;
2568
2569         if (!r_drawentities.integer)
2570                 return;
2571
2572         for (i = 0;i < r_refdef.scene.numentities;i++)
2573         {
2574                 if (!r_refdef.viewcache.entityvisible[i])
2575                         continue;
2576                 ent = r_refdef.scene.entities[i];
2577                 if (ent->model && ent->model->DrawDepth != NULL)
2578                         ent->model->DrawDepth(ent);
2579         }
2580 }
2581
2582 static void R_DrawModelsDebug(void)
2583 {
2584         int i;
2585         entity_render_t *ent;
2586
2587         if (!r_drawentities.integer)
2588                 return;
2589
2590         for (i = 0;i < r_refdef.scene.numentities;i++)
2591         {
2592                 if (!r_refdef.viewcache.entityvisible[i])
2593                         continue;
2594                 ent = r_refdef.scene.entities[i];
2595                 if (ent->model && ent->model->DrawDebug != NULL)
2596                         ent->model->DrawDebug(ent);
2597         }
2598 }
2599
2600 static void R_DrawModelsAddWaterPlanes(void)
2601 {
2602         int i;
2603         entity_render_t *ent;
2604
2605         if (!r_drawentities.integer)
2606                 return;
2607
2608         for (i = 0;i < r_refdef.scene.numentities;i++)
2609         {
2610                 if (!r_refdef.viewcache.entityvisible[i])
2611                         continue;
2612                 ent = r_refdef.scene.entities[i];
2613                 if (ent->model && ent->model->DrawAddWaterPlanes != NULL)
2614                         ent->model->DrawAddWaterPlanes(ent);
2615         }
2616 }
2617
2618 static void R_View_SetFrustum(void)
2619 {
2620         int i;
2621         double slopex, slopey;
2622         vec3_t forward, left, up, origin;
2623
2624         // we can't trust r_refdef.view.forward and friends in reflected scenes
2625         Matrix4x4_ToVectors(&r_refdef.view.matrix, forward, left, up, origin);
2626
2627 #if 0
2628         r_refdef.view.frustum[0].normal[0] = 0 - 1.0 / r_refdef.view.frustum_x;
2629         r_refdef.view.frustum[0].normal[1] = 0 - 0;
2630         r_refdef.view.frustum[0].normal[2] = -1 - 0;
2631         r_refdef.view.frustum[1].normal[0] = 0 + 1.0 / r_refdef.view.frustum_x;
2632         r_refdef.view.frustum[1].normal[1] = 0 + 0;
2633         r_refdef.view.frustum[1].normal[2] = -1 + 0;
2634         r_refdef.view.frustum[2].normal[0] = 0 - 0;
2635         r_refdef.view.frustum[2].normal[1] = 0 - 1.0 / r_refdef.view.frustum_y;
2636         r_refdef.view.frustum[2].normal[2] = -1 - 0;
2637         r_refdef.view.frustum[3].normal[0] = 0 + 0;
2638         r_refdef.view.frustum[3].normal[1] = 0 + 1.0 / r_refdef.view.frustum_y;
2639         r_refdef.view.frustum[3].normal[2] = -1 + 0;
2640 #endif
2641
2642 #if 0
2643         zNear = r_refdef.nearclip;
2644         nudge = 1.0 - 1.0 / (1<<23);
2645         r_refdef.view.frustum[4].normal[0] = 0 - 0;
2646         r_refdef.view.frustum[4].normal[1] = 0 - 0;
2647         r_refdef.view.frustum[4].normal[2] = -1 - -nudge;
2648         r_refdef.view.frustum[4].dist = 0 - -2 * zNear * nudge;
2649         r_refdef.view.frustum[5].normal[0] = 0 + 0;
2650         r_refdef.view.frustum[5].normal[1] = 0 + 0;
2651         r_refdef.view.frustum[5].normal[2] = -1 + -nudge;
2652         r_refdef.view.frustum[5].dist = 0 + -2 * zNear * nudge;
2653 #endif
2654
2655
2656
2657 #if 0
2658         r_refdef.view.frustum[0].normal[0] = m[3] - m[0];
2659         r_refdef.view.frustum[0].normal[1] = m[7] - m[4];
2660         r_refdef.view.frustum[0].normal[2] = m[11] - m[8];
2661         r_refdef.view.frustum[0].dist = m[15] - m[12];
2662
2663         r_refdef.view.frustum[1].normal[0] = m[3] + m[0];
2664         r_refdef.view.frustum[1].normal[1] = m[7] + m[4];
2665         r_refdef.view.frustum[1].normal[2] = m[11] + m[8];
2666         r_refdef.view.frustum[1].dist = m[15] + m[12];
2667
2668         r_refdef.view.frustum[2].normal[0] = m[3] - m[1];
2669         r_refdef.view.frustum[2].normal[1] = m[7] - m[5];
2670         r_refdef.view.frustum[2].normal[2] = m[11] - m[9];
2671         r_refdef.view.frustum[2].dist = m[15] - m[13];
2672
2673         r_refdef.view.frustum[3].normal[0] = m[3] + m[1];
2674         r_refdef.view.frustum[3].normal[1] = m[7] + m[5];
2675         r_refdef.view.frustum[3].normal[2] = m[11] + m[9];
2676         r_refdef.view.frustum[3].dist = m[15] + m[13];
2677
2678         r_refdef.view.frustum[4].normal[0] = m[3] - m[2];
2679         r_refdef.view.frustum[4].normal[1] = m[7] - m[6];
2680         r_refdef.view.frustum[4].normal[2] = m[11] - m[10];
2681         r_refdef.view.frustum[4].dist = m[15] - m[14];
2682
2683         r_refdef.view.frustum[5].normal[0] = m[3] + m[2];
2684         r_refdef.view.frustum[5].normal[1] = m[7] + m[6];
2685         r_refdef.view.frustum[5].normal[2] = m[11] + m[10];
2686         r_refdef.view.frustum[5].dist = m[15] + m[14];
2687 #endif
2688
2689         if (r_refdef.view.useperspective)
2690         {
2691                 slopex = 1.0 / r_refdef.view.frustum_x;
2692                 slopey = 1.0 / r_refdef.view.frustum_y;
2693                 VectorMA(forward, -slopex, left, r_refdef.view.frustum[0].normal);
2694                 VectorMA(forward,  slopex, left, r_refdef.view.frustum[1].normal);
2695                 VectorMA(forward, -slopey, up  , r_refdef.view.frustum[2].normal);
2696                 VectorMA(forward,  slopey, up  , r_refdef.view.frustum[3].normal);
2697                 VectorCopy(forward, r_refdef.view.frustum[4].normal);
2698
2699                 // Leaving those out was a mistake, those were in the old code, and they
2700                 // fix a reproducable bug in this one: frustum culling got fucked up when viewmatrix was an identity matrix
2701                 // I couldn't reproduce it after adding those normalizations. --blub
2702                 VectorNormalize(r_refdef.view.frustum[0].normal);
2703                 VectorNormalize(r_refdef.view.frustum[1].normal);
2704                 VectorNormalize(r_refdef.view.frustum[2].normal);
2705                 VectorNormalize(r_refdef.view.frustum[3].normal);
2706
2707                 // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
2708                 VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward, -1024 * slopex, left, -1024 * slopey, up, r_refdef.view.frustumcorner[0]);
2709                 VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward,  1024 * slopex, left, -1024 * slopey, up, r_refdef.view.frustumcorner[1]);
2710                 VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward, -1024 * slopex, left,  1024 * slopey, up, r_refdef.view.frustumcorner[2]);
2711                 VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward,  1024 * slopex, left,  1024 * slopey, up, r_refdef.view.frustumcorner[3]);
2712
2713                 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal);
2714                 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal);
2715                 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal);
2716                 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal);
2717                 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
2718         }
2719         else
2720         {
2721                 VectorScale(left, -r_refdef.view.ortho_x, r_refdef.view.frustum[0].normal);
2722                 VectorScale(left,  r_refdef.view.ortho_x, r_refdef.view.frustum[1].normal);
2723                 VectorScale(up, -r_refdef.view.ortho_y, r_refdef.view.frustum[2].normal);
2724                 VectorScale(up,  r_refdef.view.ortho_y, r_refdef.view.frustum[3].normal);
2725                 VectorCopy(forward, r_refdef.view.frustum[4].normal);
2726                 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal) + r_refdef.view.ortho_x;
2727                 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal) + r_refdef.view.ortho_x;
2728                 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal) + r_refdef.view.ortho_y;
2729                 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal) + r_refdef.view.ortho_y;
2730                 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
2731         }
2732         r_refdef.view.numfrustumplanes = 5;
2733
2734         if (r_refdef.view.useclipplane)
2735         {
2736                 r_refdef.view.numfrustumplanes = 6;
2737                 r_refdef.view.frustum[5] = r_refdef.view.clipplane;
2738         }
2739
2740         for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
2741                 PlaneClassify(r_refdef.view.frustum + i);
2742
2743         // LordHavoc: note to all quake engine coders, Quake had a special case
2744         // for 90 degrees which assumed a square view (wrong), so I removed it,
2745         // Quake2 has it disabled as well.
2746
2747         // rotate R_VIEWFORWARD right by FOV_X/2 degrees
2748         //RotatePointAroundVector( r_refdef.view.frustum[0].normal, up, forward, -(90 - r_refdef.fov_x / 2));
2749         //r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, frustum[0].normal);
2750         //PlaneClassify(&frustum[0]);
2751
2752         // rotate R_VIEWFORWARD left by FOV_X/2 degrees
2753         //RotatePointAroundVector( r_refdef.view.frustum[1].normal, up, forward, (90 - r_refdef.fov_x / 2));
2754         //r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, frustum[1].normal);
2755         //PlaneClassify(&frustum[1]);
2756
2757         // rotate R_VIEWFORWARD up by FOV_X/2 degrees
2758         //RotatePointAroundVector( r_refdef.view.frustum[2].normal, left, forward, -(90 - r_refdef.fov_y / 2));
2759         //r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, frustum[2].normal);
2760         //PlaneClassify(&frustum[2]);
2761
2762         // rotate R_VIEWFORWARD down by FOV_X/2 degrees
2763         //RotatePointAroundVector( r_refdef.view.frustum[3].normal, left, forward, (90 - r_refdef.fov_y / 2));
2764         //r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, frustum[3].normal);
2765         //PlaneClassify(&frustum[3]);
2766
2767         // nearclip plane
2768         //VectorCopy(forward, r_refdef.view.frustum[4].normal);
2769         //r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, frustum[4].normal) + r_nearclip.value;
2770         //PlaneClassify(&frustum[4]);
2771 }
2772
2773 void R_View_Update(void)
2774 {
2775         R_View_SetFrustum();
2776         R_View_WorldVisibility(r_refdef.view.useclipplane);
2777         R_View_UpdateEntityVisible();
2778 }
2779
2780 void R_SetupView(qboolean allowwaterclippingplane)
2781 {
2782         if (!r_refdef.view.useperspective)
2783                 GL_SetupView_Mode_Ortho(-r_refdef.view.ortho_x, -r_refdef.view.ortho_y, r_refdef.view.ortho_x, r_refdef.view.ortho_y, -r_refdef.farclip, r_refdef.farclip);
2784         else if (r_refdef.rtworldshadows || r_refdef.rtdlightshadows)
2785                 GL_SetupView_Mode_PerspectiveInfiniteFarClip(r_refdef.view.frustum_x, r_refdef.view.frustum_y, r_refdef.nearclip);
2786         else
2787                 GL_SetupView_Mode_Perspective(r_refdef.view.frustum_x, r_refdef.view.frustum_y, r_refdef.nearclip, r_refdef.farclip);
2788
2789         GL_SetupView_Orientation_FromEntity(&r_refdef.view.matrix);
2790
2791         if (r_refdef.view.useclipplane && allowwaterclippingplane)
2792         {
2793                 // LordHavoc: couldn't figure out how to make this approach the
2794                 vec_t dist = r_refdef.view.clipplane.dist - r_water_clippingplanebias.value;
2795                 vec_t viewdist = DotProduct(r_refdef.view.origin, r_refdef.view.clipplane.normal);
2796                 if (viewdist < r_refdef.view.clipplane.dist + r_water_clippingplanebias.value)
2797                         dist = r_refdef.view.clipplane.dist;
2798                 GL_SetupView_ApplyCustomNearClipPlane(r_refdef.view.clipplane.normal[0], r_refdef.view.clipplane.normal[1], r_refdef.view.clipplane.normal[2], dist);
2799         }
2800 }
2801
2802 void R_ResetViewRendering2D(void)
2803 {
2804         DrawQ_Finish();
2805
2806         // GL is weird because it's bottom to top, r_refdef.view.y is top to bottom
2807         qglViewport(r_refdef.view.x, vid.height - (r_refdef.view.y + r_refdef.view.height), r_refdef.view.width, r_refdef.view.height);CHECKGLERROR
2808         GL_SetupView_Mode_Ortho(0, 0, 1, 1, -10, 100);
2809         GL_Scissor(r_refdef.view.x, r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
2810         GL_Color(1, 1, 1, 1);
2811         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
2812         GL_BlendFunc(GL_ONE, GL_ZERO);
2813         GL_AlphaTest(false);
2814         GL_ScissorTest(false);
2815         GL_DepthMask(false);
2816         GL_DepthRange(0, 1);
2817         GL_DepthTest(false);
2818         R_Mesh_Matrix(&identitymatrix);
2819         R_Mesh_ResetTextureState();
2820         GL_PolygonOffset(0, 0);
2821         qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
2822         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
2823         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2824         qglStencilMask(~0);CHECKGLERROR
2825         qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
2826         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
2827         GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces
2828         R_SetupGenericShader(true);
2829 }
2830
2831 void R_ResetViewRendering3D(void)
2832 {
2833         DrawQ_Finish();
2834
2835         // GL is weird because it's bottom to top, r_refdef.view.y is top to bottom
2836         qglViewport(r_refdef.view.x, vid.height - (r_refdef.view.y + r_refdef.view.height), r_refdef.view.width, r_refdef.view.height);CHECKGLERROR
2837         R_SetupView(true);
2838         GL_Scissor(r_refdef.view.x, r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
2839         GL_Color(1, 1, 1, 1);
2840         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
2841         GL_BlendFunc(GL_ONE, GL_ZERO);
2842         GL_AlphaTest(false);
2843         GL_ScissorTest(true);
2844         GL_DepthMask(true);
2845         GL_DepthRange(0, 1);
2846         GL_DepthTest(true);
2847         R_Mesh_Matrix(&identitymatrix);
2848         R_Mesh_ResetTextureState();
2849         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
2850         qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
2851         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
2852         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2853         qglStencilMask(~0);CHECKGLERROR
2854         qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
2855         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
2856         GL_CullFace(r_refdef.view.cullface_back);
2857         R_SetupGenericShader(true);
2858 }
2859
2860 void R_RenderScene(qboolean addwaterplanes);
2861
2862 static void R_Water_StartFrame(void)
2863 {
2864         int i;
2865         int waterwidth, waterheight, texturewidth, textureheight;
2866         r_waterstate_waterplane_t *p;
2867
2868         // set waterwidth and waterheight to the water resolution that will be
2869         // used (often less than the screen resolution for faster rendering)
2870         waterwidth = (int)bound(1, r_refdef.view.width * r_water_resolutionmultiplier.value, r_refdef.view.width);
2871         waterheight = (int)bound(1, r_refdef.view.height * r_water_resolutionmultiplier.value, r_refdef.view.height);
2872
2873         // calculate desired texture sizes
2874         // can't use water if the card does not support the texture size
2875         if (!r_water.integer || !r_glsl.integer || !gl_support_fragment_shader || waterwidth > gl_max_texture_size || waterheight > gl_max_texture_size)
2876                 texturewidth = textureheight = waterwidth = waterheight = 0;
2877         else if (gl_support_arb_texture_non_power_of_two)
2878         {
2879                 texturewidth = waterwidth;
2880                 textureheight = waterheight;
2881         }
2882         else
2883         {
2884                 for (texturewidth   = 1;texturewidth   < waterwidth ;texturewidth   *= 2);
2885                 for (textureheight  = 1;textureheight  < waterheight;textureheight  *= 2);
2886         }
2887
2888         // allocate textures as needed
2889         if (r_waterstate.waterwidth != waterwidth || r_waterstate.waterheight != waterheight || r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight)
2890         {
2891                 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
2892                 for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
2893                 {
2894                         if (p->texture_refraction)
2895                                 R_FreeTexture(p->texture_refraction);
2896                         p->texture_refraction = NULL;
2897                         if (p->texture_reflection)
2898                                 R_FreeTexture(p->texture_reflection);
2899                         p->texture_reflection = NULL;
2900                 }
2901                 memset(&r_waterstate, 0, sizeof(r_waterstate));
2902                 r_waterstate.waterwidth = waterwidth;
2903                 r_waterstate.waterheight = waterheight;
2904                 r_waterstate.texturewidth = texturewidth;
2905                 r_waterstate.textureheight = textureheight;
2906         }
2907
2908         if (r_waterstate.waterwidth)
2909         {
2910                 r_waterstate.enabled = true;
2911
2912                 // set up variables that will be used in shader setup
2913                 r_waterstate.screenscale[0] = 0.5f * (float)waterwidth / (float)texturewidth;
2914                 r_waterstate.screenscale[1] = 0.5f * (float)waterheight / (float)textureheight;
2915                 r_waterstate.screencenter[0] = 0.5f * (float)waterwidth / (float)texturewidth;
2916                 r_waterstate.screencenter[1] = 0.5f * (float)waterheight / (float)textureheight;
2917         }
2918
2919         r_waterstate.maxwaterplanes = MAX_WATERPLANES;
2920         r_waterstate.numwaterplanes = 0;
2921 }
2922
2923 static void R_Water_AddWaterPlane(msurface_t *surface)
2924 {
2925         int triangleindex, planeindex;
2926         const int *e;
2927         vec3_t vert[3];
2928         vec3_t normal;
2929         vec3_t center;
2930         r_waterstate_waterplane_t *p;
2931         // just use the first triangle with a valid normal for any decisions
2932         VectorClear(normal);
2933         for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
2934         {
2935                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
2936                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
2937                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
2938                 TriangleNormal(vert[0], vert[1], vert[2], normal);
2939                 if (VectorLength2(normal) >= 0.001)
2940                         break;
2941         }
2942
2943         // find a matching plane if there is one
2944         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2945                 if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
2946                         break;
2947         if (planeindex >= r_waterstate.maxwaterplanes)
2948                 return; // nothing we can do, out of planes
2949
2950         // if this triangle does not fit any known plane rendered this frame, add one
2951         if (planeindex >= r_waterstate.numwaterplanes)
2952         {
2953                 // store the new plane
2954                 r_waterstate.numwaterplanes++;
2955                 VectorCopy(normal, p->plane.normal);
2956                 VectorNormalize(p->plane.normal);
2957                 p->plane.dist = DotProduct(vert[0], p->plane.normal);
2958                 PlaneClassify(&p->plane);
2959                 // flip the plane if it does not face the viewer
2960                 if (PlaneDiff(r_refdef.view.origin, &p->plane) < 0)
2961                 {
2962                         VectorNegate(p->plane.normal, p->plane.normal);
2963                         p->plane.dist *= -1;
2964                         PlaneClassify(&p->plane);
2965                 }
2966                 // clear materialflags and pvs
2967                 p->materialflags = 0;
2968                 p->pvsvalid = false;
2969         }
2970         // merge this surface's materialflags into the waterplane
2971         p->materialflags |= surface->texture->currentframe->currentmaterialflags;
2972         // merge this surface's PVS into the waterplane
2973         VectorMAM(0.5f, surface->mins, 0.5f, surface->maxs, center);
2974         if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS
2975          && r_refdef.scene.worldmodel->brush.PointInLeaf && r_refdef.scene.worldmodel->brush.PointInLeaf(r_refdef.scene.worldmodel, center)->clusterindex >= 0)
2976         {
2977                 r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, center, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
2978                 p->pvsvalid = true;
2979         }
2980 }
2981
2982 static void R_Water_ProcessPlanes(void)
2983 {
2984         r_refdef_view_t originalview;
2985         int planeindex;
2986         r_waterstate_waterplane_t *p;
2987
2988         originalview = r_refdef.view;
2989
2990         // make sure enough textures are allocated
2991         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2992         {
2993                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
2994                 {
2995                         if (!p->texture_refraction)
2996                                 p->texture_refraction = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_refraction", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
2997                         if (!p->texture_refraction)
2998                                 goto error;
2999                 }
3000
3001                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
3002                 {
3003                         if (!p->texture_reflection)
3004                                 p->texture_reflection = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_reflection", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
3005                         if (!p->texture_reflection)
3006                                 goto error;
3007                 }
3008         }
3009
3010         // render views
3011         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
3012         {
3013                 r_refdef.view.showdebug = false;
3014                 r_refdef.view.width = r_waterstate.waterwidth;
3015                 r_refdef.view.height = r_waterstate.waterheight;
3016                 r_refdef.view.useclipplane = true;
3017                 r_waterstate.renderingscene = true;
3018
3019                 // render the normal view scene and copy into texture
3020                 // (except that a clipping plane should be used to hide everything on one side of the water, and the viewer's weapon model should be omitted)
3021                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
3022                 {
3023                         r_refdef.view.clipplane = p->plane;
3024                         VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
3025                         r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
3026                         PlaneClassify(&r_refdef.view.clipplane);
3027
3028                         R_RenderScene(false);
3029
3030                         // copy view into the screen texture
3031                         R_Mesh_TexBind(0, R_GetTexture(p->texture_refraction));
3032                         GL_ActiveTexture(0);
3033                         CHECKGLERROR
3034                         qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_refdef.view.x, vid.height - (r_refdef.view.y + r_refdef.view.height), r_refdef.view.width, r_refdef.view.height);CHECKGLERROR
3035                 }
3036
3037                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
3038                 {
3039                         // render reflected scene and copy into texture
3040                         Matrix4x4_Reflect(&r_refdef.view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
3041                         // update the r_refdef.view.origin because otherwise the sky renders at the wrong location (amongst other problems)
3042                         Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, r_refdef.view.origin);
3043                         r_refdef.view.clipplane = p->plane;
3044                         // reverse the cullface settings for this render
3045                         r_refdef.view.cullface_front = GL_FRONT;
3046                         r_refdef.view.cullface_back = GL_BACK;
3047                         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.num_pvsclusterbytes)
3048                         {
3049                                 r_refdef.view.usecustompvs = true;
3050                                 if (p->pvsvalid)
3051                                         memcpy(r_refdef.viewcache.world_pvsbits, p->pvsbits, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
3052                                 else
3053                                         memset(r_refdef.viewcache.world_pvsbits, 0xFF, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
3054                         }
3055
3056                         R_ResetViewRendering3D();
3057                         R_ClearScreen(r_refdef.fogenabled);
3058                         if (r_timereport_active)
3059                                 R_TimeReport("viewclear");
3060
3061                         R_RenderScene(false);
3062
3063                         R_Mesh_TexBind(0, R_GetTexture(p->texture_reflection));
3064                         GL_ActiveTexture(0);
3065                         CHECKGLERROR
3066                         qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_refdef.view.x, vid.height - (r_refdef.view.y + r_refdef.view.height), r_refdef.view.width, r_refdef.view.height);CHECKGLERROR
3067
3068                         R_ResetViewRendering3D();
3069                         R_ClearScreen(r_refdef.fogenabled);
3070                         if (r_timereport_active)
3071                                 R_TimeReport("viewclear");
3072                 }
3073
3074                 r_refdef.view = originalview;
3075                 r_refdef.view.clear = true;
3076                 r_waterstate.renderingscene = false;
3077         }
3078         return;
3079 error:
3080         r_refdef.view = originalview;
3081         r_waterstate.renderingscene = false;
3082         Cvar_SetValueQuick(&r_water, 0);
3083         Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed!  Turned off r_water.\n");
3084         return;
3085 }
3086
3087 void R_Bloom_StartFrame(void)
3088 {
3089         int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
3090
3091         // set bloomwidth and bloomheight to the bloom resolution that will be
3092         // used (often less than the screen resolution for faster rendering)
3093         r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, r_refdef.view.width);
3094         r_bloomstate.bloomheight = r_bloomstate.bloomwidth * r_refdef.view.height / r_refdef.view.width;
3095         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_refdef.view.height);
3096         r_bloomstate.bloomwidth = min(r_bloomstate.bloomwidth, gl_max_texture_size);
3097         r_bloomstate.bloomheight = min(r_bloomstate.bloomheight, gl_max_texture_size);
3098
3099         // calculate desired texture sizes
3100         if (gl_support_arb_texture_non_power_of_two)
3101         {
3102                 screentexturewidth = r_refdef.view.width;
3103                 screentextureheight = r_refdef.view.height;
3104                 bloomtexturewidth = r_bloomstate.bloomwidth;
3105                 bloomtextureheight = r_bloomstate.bloomheight;
3106         }
3107         else
3108         {
3109                 for (screentexturewidth  = 1;screentexturewidth  < vid.width               ;screentexturewidth  *= 2);
3110                 for (screentextureheight = 1;screentextureheight < vid.height              ;screentextureheight *= 2);
3111                 for (bloomtexturewidth   = 1;bloomtexturewidth   < r_bloomstate.bloomwidth ;bloomtexturewidth   *= 2);
3112                 for (bloomtextureheight  = 1;bloomtextureheight  < r_bloomstate.bloomheight;bloomtextureheight  *= 2);
3113         }
3114
3115         if ((r_hdr.integer || r_bloom.integer) && ((r_bloom_resolution.integer < 4 || r_bloom_blur.value < 1 || r_bloom_blur.value >= 512) || r_refdef.view.width > gl_max_texture_size || r_refdef.view.height > gl_max_texture_size))
3116         {
3117                 Cvar_SetValueQuick(&r_hdr, 0);
3118                 Cvar_SetValueQuick(&r_bloom, 0);
3119         }
3120
3121         if (!(r_glsl.integer && (r_glsl_postprocess.integer || r_bloom.integer || r_hdr.integer)) && !r_bloom.integer)
3122                 screentexturewidth = screentextureheight = 0;
3123         if (!r_hdr.integer && !r_bloom.integer)
3124                 bloomtexturewidth = bloomtextureheight = 0;
3125
3126         // allocate textures as needed
3127         if (r_bloomstate.screentexturewidth != screentexturewidth || r_bloomstate.screentextureheight != screentextureheight)
3128         {
3129                 if (r_bloomstate.texture_screen)
3130                         R_FreeTexture(r_bloomstate.texture_screen);
3131                 r_bloomstate.texture_screen = NULL;
3132                 r_bloomstate.screentexturewidth = screentexturewidth;
3133                 r_bloomstate.screentextureheight = screentextureheight;
3134                 if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight)
3135                         r_bloomstate.texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", r_bloomstate.screentexturewidth, r_bloomstate.screentextureheight, NULL, TEXTYPE_BGRA, TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
3136         }
3137         if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight)
3138         {
3139                 if (r_bloomstate.texture_bloom)
3140                         R_FreeTexture(r_bloomstate.texture_bloom);
3141                 r_bloomstate.texture_bloom = NULL;
3142                 r_bloomstate.bloomtexturewidth = bloomtexturewidth;
3143                 r_bloomstate.bloomtextureheight = bloomtextureheight;
3144                 if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight)
3145                         r_bloomstate.texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", r_bloomstate.bloomtexturewidth, r_bloomstate.bloomtextureheight, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
3146         }
3147
3148         // set up a texcoord array for the full resolution screen image
3149         // (we have to keep this around to copy back during final render)
3150         r_bloomstate.screentexcoord2f[0] = 0;
3151         r_bloomstate.screentexcoord2f[1] = (float)r_refdef.view.height    / (float)r_bloomstate.screentextureheight;
3152         r_bloomstate.screentexcoord2f[2] = (float)r_refdef.view.width     / (float)r_bloomstate.screentexturewidth;
3153         r_bloomstate.screentexcoord2f[3] = (float)r_refdef.view.height    / (float)r_bloomstate.screentextureheight;
3154         r_bloomstate.screentexcoord2f[4] = (float)r_refdef.view.width     / (float)r_bloomstate.screentexturewidth;
3155         r_bloomstate.screentexcoord2f[5] = 0;
3156         r_bloomstate.screentexcoord2f[6] = 0;
3157         r_bloomstate.screentexcoord2f[7] = 0;
3158
3159         // set up a texcoord array for the reduced resolution bloom image
3160         // (which will be additive blended over the screen image)
3161         r_bloomstate.bloomtexcoord2f[0] = 0;
3162         r_bloomstate.bloomtexcoord2f[1] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
3163         r_bloomstate.bloomtexcoord2f[2] = (float)r_bloomstate.bloomwidth  / (float)r_bloomstate.bloomtexturewidth;
3164         r_bloomstate.bloomtexcoord2f[3] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
3165         r_bloomstate.bloomtexcoord2f[4] = (float)r_bloomstate.bloomwidth  / (float)r_bloomstate.bloomtexturewidth;
3166         r_bloomstate.bloomtexcoord2f[5] = 0;
3167         r_bloomstate.bloomtexcoord2f[6] = 0;
3168         r_bloomstate.bloomtexcoord2f[7] = 0;
3169
3170         if (r_hdr.integer || r_bloom.integer)
3171         {
3172                 r_bloomstate.enabled = true;
3173                 r_bloomstate.hdr = r_hdr.integer != 0;
3174         }
3175 }
3176
3177 void R_Bloom_CopyBloomTexture(float colorscale)
3178 {
3179         r_refdef.stats.bloom++;
3180
3181         // scale down screen texture to the bloom texture size
3182         CHECKGLERROR
3183         qglViewport(r_refdef.view.x, vid.height - (r_refdef.view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
3184         GL_BlendFunc(GL_ONE, GL_ZERO);
3185         GL_Color(colorscale, colorscale, colorscale, 1);
3186         // TODO: optimize with multitexture or GLSL
3187         R_SetupGenericShader(true);
3188         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
3189         R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen));
3190         R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3191         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3192
3193         // we now have a bloom image in the framebuffer
3194         // copy it into the bloom image texture for later processing
3195         R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3196         GL_ActiveTexture(0);
3197         CHECKGLERROR
3198         qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_refdef.view.x, vid.height - (r_refdef.view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
3199         r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3200 }
3201
3202 void R_Bloom_CopyHDRTexture(void)
3203 {
3204         R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3205         GL_ActiveTexture(0);
3206         CHECKGLERROR
3207         qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_refdef.view.x, vid.height - (r_refdef.view.y + r_refdef.view.height), r_refdef.view.width, r_refdef.view.height);CHECKGLERROR
3208         r_refdef.stats.bloom_copypixels += r_refdef.view.width * r_refdef.view.height;
3209 }
3210
3211 void R_Bloom_MakeTexture(void)
3212 {
3213         int x, range, dir;
3214         float xoffset, yoffset, r, brighten;
3215
3216         r_refdef.stats.bloom++;
3217
3218         R_ResetViewRendering2D();
3219         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3220         R_Mesh_ColorPointer(NULL, 0, 0);
3221         R_SetupGenericShader(true);
3222
3223         // we have a bloom image in the framebuffer
3224         CHECKGLERROR
3225         qglViewport(r_refdef.view.x, vid.height - (r_refdef.view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
3226
3227         for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
3228         {
3229                 x *= 2;
3230                 r = bound(0, r_bloom_colorexponent.value / x, 1);
3231                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
3232                 GL_Color(r, r, r, 1);
3233                 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3234                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3235                 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3236                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3237
3238                 // copy the vertically blurred bloom view to a texture
3239                 GL_ActiveTexture(0);
3240                 CHECKGLERROR
3241                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_refdef.view.x, vid.height - (r_refdef.view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
3242                 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3243         }
3244
3245         range = r_bloom_blur.integer * r_bloomstate.bloomwidth / 320;
3246         brighten = r_bloom_brighten.value;
3247         if (r_hdr.integer)
3248                 brighten *= r_hdr_range.value;
3249         R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3250         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.offsettexcoord2f, 0, 0);
3251
3252         for (dir = 0;dir < 2;dir++)
3253         {
3254                 // blend on at multiple vertical offsets to achieve a vertical blur
3255                 // TODO: do offset blends using GLSL
3256                 GL_BlendFunc(GL_ONE, GL_ZERO);
3257                 for (x = -range;x <= range;x++)
3258                 {
3259                         if (!dir){xoffset = 0;yoffset = x;}
3260                         else {xoffset = x;yoffset = 0;}
3261                         xoffset /= (float)r_bloomstate.bloomtexturewidth;
3262                         yoffset /= (float)r_bloomstate.bloomtextureheight;
3263                         // compute a texcoord array with the specified x and y offset
3264                         r_bloomstate.offsettexcoord2f[0] = xoffset+0;
3265                         r_bloomstate.offsettexcoord2f[1] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
3266                         r_bloomstate.offsettexcoord2f[2] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
3267                         r_bloomstate.offsettexcoord2f[3] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
3268                         r_bloomstate.offsettexcoord2f[4] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
3269                         r_bloomstate.offsettexcoord2f[5] = yoffset+0;
3270                         r_bloomstate.offsettexcoord2f[6] = xoffset+0;
3271                         r_bloomstate.offsettexcoord2f[7] = yoffset+0;
3272                         // this r value looks like a 'dot' particle, fading sharply to
3273                         // black at the edges
3274                         // (probably not realistic but looks good enough)
3275                         //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
3276                         //r = (dir ? 1.0f : brighten)/(range*2+1);
3277                         r = (dir ? 1.0f : brighten)/(range*2+1)*(1 - x*x/(float)(range*range));
3278                         GL_Color(r, r, r, 1);
3279                         R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3280                         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3281                         GL_BlendFunc(GL_ONE, GL_ONE);
3282                 }
3283
3284                 // copy the vertically blurred bloom view to a texture
3285                 GL_ActiveTexture(0);
3286                 CHECKGLERROR
3287                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_refdef.view.x, vid.height - (r_refdef.view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
3288                 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3289         }
3290
3291         // apply subtract last
3292         // (just like it would be in a GLSL shader)
3293         if (r_bloom_colorsubtract.value > 0 && gl_support_ext_blend_subtract)
3294         {
3295                 GL_BlendFunc(GL_ONE, GL_ZERO);
3296                 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3297                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3298                 GL_Color(1, 1, 1, 1);
3299                 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3300                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3301
3302                 GL_BlendFunc(GL_ONE, GL_ONE);
3303                 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
3304                 R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
3305                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3306                 GL_Color(r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 1);
3307                 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3308                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3309                 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
3310
3311                 // copy the darkened bloom view to a texture
3312                 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3313                 GL_ActiveTexture(0);
3314                 CHECKGLERROR
3315                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_refdef.view.x, vid.height - (r_refdef.view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
3316                 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3317         }
3318 }
3319
3320 void R_HDR_RenderBloomTexture(void)
3321 {
3322         int oldwidth, oldheight;
3323         float oldcolorscale;
3324
3325         oldcolorscale = r_refdef.view.colorscale;
3326         oldwidth = r_refdef.view.width;
3327         oldheight = r_refdef.view.height;
3328         r_refdef.view.width = r_bloomstate.bloomwidth;
3329         r_refdef.view.height = r_bloomstate.bloomheight;
3330
3331         // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer?  it might improve SLI performance.
3332         // TODO: add exposure compensation features
3333         // TODO: add fp16 framebuffer support
3334
3335         r_refdef.view.showdebug = false;
3336         r_refdef.view.colorscale *= r_bloom_colorscale.value / bound(1, r_hdr_range.value, 16);
3337
3338         R_ClearScreen(r_refdef.fogenabled);
3339         if (r_timereport_active)
3340                 R_TimeReport("HDRclear");
3341
3342         r_waterstate.numwaterplanes = 0;
3343         R_RenderScene(r_waterstate.enabled);
3344         r_refdef.view.showdebug = true;
3345
3346         R_ResetViewRendering2D();
3347
3348         R_Bloom_CopyHDRTexture();
3349         R_Bloom_MakeTexture();
3350
3351         // restore the view settings
3352         r_refdef.view.width = oldwidth;
3353         r_refdef.view.height = oldheight;
3354         r_refdef.view.colorscale = oldcolorscale;
3355
3356         R_ResetViewRendering3D();
3357
3358         R_ClearScreen(r_refdef.fogenabled);
3359         if (r_timereport_active)
3360                 R_TimeReport("viewclear");
3361 }
3362
3363 static void R_BlendView(void)
3364 {
3365         if (r_bloomstate.texture_screen)
3366         {
3367                 // copy view into the screen texture
3368                 R_ResetViewRendering2D();
3369                 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3370                 R_Mesh_ColorPointer(NULL, 0, 0);
3371                 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen));
3372                 GL_ActiveTexture(0);CHECKGLERROR
3373                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_refdef.view.x, vid.height - (r_refdef.view.y + r_refdef.view.height), r_refdef.view.width, r_refdef.view.height);CHECKGLERROR
3374                 r_refdef.stats.bloom_copypixels += r_refdef.view.width * r_refdef.view.height;
3375         }
3376
3377         if (r_glsl.integer && gl_support_fragment_shader && (r_bloomstate.texture_screen || r_bloomstate.texture_bloom))
3378         {
3379                 unsigned int permutation =
3380                           (r_bloomstate.texture_bloom ? SHADERPERMUTATION_GLOW : 0)
3381                         | (r_refdef.viewblend[3] > 0 ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0);
3382                 if(r_glsl_postprocess.value)
3383                         permutation |= SHADERPERMUTATION_POSTPROCESSING
3384                             | (r_glsl_postprocess_contrastboost.value != 1 ? SHADERPERMUTATION_CONTRASTBOOST : 0)
3385                                 | (r_glsl_postprocess_gamma.value != 1 ? SHADERPERMUTATION_GAMMA : 0);
3386
3387                 if (r_bloomstate.texture_bloom && !r_bloomstate.hdr)
3388                 {
3389                         // render simple bloom effect
3390                         // copy the screen and shrink it and darken it for the bloom process
3391                         R_Bloom_CopyBloomTexture(r_bloom_colorscale.value);
3392                         // make the bloom texture
3393                         R_Bloom_MakeTexture();
3394                 }
3395
3396                 R_ResetViewRendering2D();
3397                 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3398                 R_Mesh_ColorPointer(NULL, 0, 0);
3399                 GL_Color(1, 1, 1, 1);
3400                 GL_BlendFunc(GL_ONE, GL_ZERO);
3401                 R_SetupShader_SetPermutation(SHADERMODE_POSTPROCESS, permutation);
3402                 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen));
3403                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
3404                 R_Mesh_TexBind(1, R_GetTexture(r_bloomstate.texture_bloom));
3405                 R_Mesh_TexCoordPointer(1, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3406                 if (r_glsl_permutation->loc_TintColor >= 0)
3407                         qglUniform4fARB(r_glsl_permutation->loc_TintColor, r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
3408                 if (r_glsl_permutation->loc_ContrastBoostCoeff >= 0)
3409                         qglUniform1fARB(r_glsl_permutation->loc_ContrastBoostCoeff, r_glsl_postprocess_contrastboost.value - 1);
3410                 if (r_glsl_permutation->loc_GammaCoeff >= 0)
3411                         qglUniform1fARB(r_glsl_permutation->loc_GammaCoeff, 1 / r_glsl_postprocess_gamma.value);
3412                 if (r_glsl_permutation->loc_ClientTime >= 0)
3413                         qglUniform1fARB(r_glsl_permutation->loc_ClientTime, cl.time);
3414                 if (r_glsl_permutation->loc_UserVec1 >= 0)
3415                 {
3416                         float a=0, b=0, c=0, d=0;
3417                         sscanf(r_glsl_postprocess_uservec1.string, "%f %f %f %f", &a, &b, &c, &d);
3418                         qglUniform4fARB(r_glsl_permutation->loc_UserVec1, a, b, c, d);
3419                 }
3420                 if (r_glsl_permutation->loc_UserVec2 >= 0)
3421                 {
3422                         float a=0, b=0, c=0, d=0;
3423                         sscanf(r_glsl_postprocess_uservec2.string, "%f %f %f %f", &a, &b, &c, &d);
3424                         qglUniform4fARB(r_glsl_permutation->loc_UserVec2, a, b, c, d);
3425                 }
3426                 if (r_glsl_permutation->loc_UserVec3 >= 0)
3427                 {
3428                         float a=0, b=0, c=0, d=0;
3429                         sscanf(r_glsl_postprocess_uservec3.string, "%f %f %f %f", &a, &b, &c, &d);
3430                         qglUniform4fARB(r_glsl_permutation->loc_UserVec3, a, b, c, d);
3431                 }
3432                 if (r_glsl_permutation->loc_UserVec4 >= 0)
3433                 {
3434                         float a=0, b=0, c=0, d=0;
3435                         sscanf(r_glsl_postprocess_uservec4.string, "%f %f %f %f", &a, &b, &c, &d);
3436                         qglUniform4fARB(r_glsl_permutation->loc_UserVec4, a, b, c, d);
3437                 }
3438                 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3439                 r_refdef.stats.bloom_drawpixels += r_refdef.view.width * r_refdef.view.height;
3440                 return;
3441         }
3442
3443
3444
3445         if (r_bloomstate.texture_bloom && r_bloomstate.hdr)
3446         {
3447                 // render high dynamic range bloom effect
3448                 // the bloom texture was made earlier this render, so we just need to
3449                 // blend it onto the screen...
3450                 R_ResetViewRendering2D();
3451                 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3452                 R_Mesh_ColorPointer(NULL, 0, 0);
3453                 R_SetupGenericShader(true);
3454                 GL_Color(1, 1, 1, 1);
3455                 GL_BlendFunc(GL_ONE, GL_ONE);
3456                 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3457                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3458                 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3459                 r_refdef.stats.bloom_drawpixels += r_refdef.view.width * r_refdef.view.height;
3460         }
3461         else if (r_bloomstate.texture_bloom)
3462         {
3463                 // render simple bloom effect
3464                 // copy the screen and shrink it and darken it for the bloom process
3465                 R_Bloom_CopyBloomTexture(r_bloom_colorscale.value);
3466                 // make the bloom texture
3467                 R_Bloom_MakeTexture();
3468                 // put the original screen image back in place and blend the bloom
3469                 // texture on it
3470                 R_ResetViewRendering2D();
3471                 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3472                 R_Mesh_ColorPointer(NULL, 0, 0);
3473                 GL_Color(1, 1, 1, 1);
3474                 GL_BlendFunc(GL_ONE, GL_ZERO);
3475                 // do both in one pass if possible
3476                 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3477                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3478                 if (r_textureunits.integer >= 2 && gl_combine.integer)
3479                 {
3480                         R_SetupGenericTwoTextureShader(GL_ADD);
3481                         R_Mesh_TexBind(1, R_GetTexture(r_bloomstate.texture_screen));
3482                         R_Mesh_TexCoordPointer(1, 2, r_bloomstate.screentexcoord2f, 0, 0);
3483                 }
3484                 else
3485                 {
3486                         R_SetupGenericShader(true);
3487                         R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3488                         r_refdef.stats.bloom_drawpixels += r_refdef.view.width * r_refdef.view.height;
3489                         // now blend on the bloom texture
3490                         GL_BlendFunc(GL_ONE, GL_ONE);
3491                         R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen));
3492                         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
3493                 }
3494                 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3495                 r_refdef.stats.bloom_drawpixels += r_refdef.view.width * r_refdef.view.height;
3496         }
3497         if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
3498         {
3499                 // apply a color tint to the whole view
3500                 R_ResetViewRendering2D();
3501                 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3502                 R_Mesh_ColorPointer(NULL, 0, 0);
3503                 R_SetupGenericShader(false);
3504                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3505                 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
3506                 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3507         }
3508 }
3509
3510 void R_RenderScene(qboolean addwaterplanes);
3511
3512 matrix4x4_t r_waterscrollmatrix;
3513
3514 void R_UpdateFogColor(void) // needs to be called before HDR subrender too, as that changes colorscale!
3515 {
3516         if (r_refdef.fog_density)
3517         {
3518                 r_refdef.fogcolor[0] = r_refdef.fog_red;
3519                 r_refdef.fogcolor[1] = r_refdef.fog_green;
3520                 r_refdef.fogcolor[2] = r_refdef.fog_blue;
3521
3522                 {
3523                         vec3_t fogvec;
3524                         VectorCopy(r_refdef.fogcolor, fogvec);
3525                         if(r_glsl.integer && (r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)) // need to support contrast boost
3526                         {
3527                                 //   color.rgb /= ((ContrastBoost - 1) * color.rgb + 1);
3528                                 fogvec[0] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[0] + 1);
3529                                 fogvec[1] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[1] + 1);
3530                                 fogvec[2] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[2] + 1);
3531                         }
3532                         //   color.rgb *= ContrastBoost * SceneBrightness;
3533                         VectorScale(fogvec, r_refdef.view.colorscale, fogvec);
3534                         r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
3535                         r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
3536                         r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
3537                 }
3538         }
3539 }
3540
3541 void R_UpdateVariables(void)
3542 {
3543         R_Textures_Frame();
3544
3545         r_refdef.farclip = 4096;
3546         if (r_refdef.scene.worldmodel)
3547                 r_refdef.farclip += VectorDistance(r_refdef.scene.worldmodel->normalmins, r_refdef.scene.worldmodel->normalmaxs);
3548         r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
3549
3550         if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
3551                 Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
3552         r_refdef.polygonfactor = 0;
3553         r_refdef.polygonoffset = 0;
3554         r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
3555         r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
3556
3557         r_refdef.rtworld = r_shadow_realtime_world.integer;
3558         r_refdef.rtworldshadows = r_shadow_realtime_world_shadows.integer && gl_stencil;
3559         r_refdef.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer;
3560         r_refdef.rtdlightshadows = r_refdef.rtdlight && r_shadow_realtime_dlight_shadows.integer && gl_stencil;
3561         r_refdef.lightmapintensity = r_refdef.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
3562         if (r_showsurfaces.integer)
3563         {
3564                 r_refdef.rtworld = false;
3565                 r_refdef.rtworldshadows = false;
3566                 r_refdef.rtdlight = false;
3567                 r_refdef.rtdlightshadows = false;
3568                 r_refdef.lightmapintensity = 0;
3569         }
3570
3571         if (gamemode == GAME_NEHAHRA)
3572         {
3573                 if (gl_fogenable.integer)
3574                 {
3575                         r_refdef.oldgl_fogenable = true;
3576                         r_refdef.fog_density = gl_fogdensity.value;
3577                         r_refdef.fog_red = gl_fogred.value;
3578                         r_refdef.fog_green = gl_foggreen.value;
3579                         r_refdef.fog_blue = gl_fogblue.value;
3580                         r_refdef.fog_alpha = 1;
3581                         r_refdef.fog_start = 0;
3582                         r_refdef.fog_end = gl_skyclip.value;
3583                 }
3584                 else if (r_refdef.oldgl_fogenable)
3585                 {
3586                         r_refdef.oldgl_fogenable = false;
3587                         r_refdef.fog_density = 0;
3588                         r_refdef.fog_red = 0;
3589                         r_refdef.fog_green = 0;
3590                         r_refdef.fog_blue = 0;
3591                         r_refdef.fog_alpha = 0;
3592                         r_refdef.fog_start = 0;
3593                         r_refdef.fog_end = 0;
3594                 }
3595         }
3596
3597         r_refdef.fog_alpha = bound(0, r_refdef.fog_alpha, 1);
3598         r_refdef.fog_start = max(0, r_refdef.fog_start);
3599         r_refdef.fog_end = max(r_refdef.fog_start + 0.01, r_refdef.fog_end);
3600
3601         // R_UpdateFogColor(); // why? R_RenderScene does it anyway
3602
3603         if (r_refdef.fog_density)
3604         {
3605                 r_refdef.fogenabled = true;
3606                 // this is the point where the fog reaches 0.9986 alpha, which we
3607                 // consider a good enough cutoff point for the texture
3608                 // (0.9986 * 256 == 255.6)
3609                 if (r_fog_exp2.integer)
3610                         r_refdef.fogrange = 32 / (r_refdef.fog_density * r_refdef.fog_density) + r_refdef.fog_start;
3611                 else
3612                         r_refdef.fogrange = 2048 / r_refdef.fog_density + r_refdef.fog_start;
3613                 r_refdef.fogrange = bound(r_refdef.fog_start, r_refdef.fogrange, r_refdef.fog_end);
3614                 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
3615                 r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
3616                 // fog color was already set
3617                 // update the fog texture
3618                 if (r_refdef.fogmasktable_start != r_refdef.fog_start || r_refdef.fogmasktable_alpha != r_refdef.fog_alpha || r_refdef.fogmasktable_density != r_refdef.fog_density || r_refdef.fogmasktable_range != r_refdef.fogrange)
3619                         R_BuildFogTexture();
3620         }
3621         else
3622                 r_refdef.fogenabled = false;
3623 }
3624
3625 static r_refdef_scene_type_t r_currentscenetype = RST_CLIENT;
3626 static r_refdef_scene_t r_scenes_store[ RST_COUNT ];
3627 /*
3628 ================
3629 R_SelectScene
3630 ================
3631 */
3632 void R_SelectScene( r_refdef_scene_type_t scenetype ) {
3633         if( scenetype != r_currentscenetype ) {
3634                 // store the old scenetype
3635                 r_scenes_store[ r_currentscenetype ] = r_refdef.scene;
3636                 r_currentscenetype = scenetype;
3637                 // move in the new scene
3638                 r_refdef.scene = r_scenes_store[ r_currentscenetype ];
3639         }
3640 }
3641
3642 /*
3643 ================
3644 R_GetScenePointer
3645 ================
3646 */
3647 r_refdef_scene_t * R_GetScenePointer( r_refdef_scene_type_t scenetype )
3648 {
3649         // of course, we could also add a qboolean that provides a lock state and a ReleaseScenePointer function..
3650         if( scenetype == r_currentscenetype ) {
3651                 return &r_refdef.scene;
3652         } else {
3653                 return &r_scenes_store[ scenetype ];
3654         }
3655 }
3656
3657 /*
3658 ================
3659 R_RenderView
3660 ================
3661 */
3662 void R_RenderView(void)
3663 {
3664         if (!r_refdef.scene.entities/* || !r_refdef.scene.worldmodel*/)
3665                 return; //Host_Error ("R_RenderView: NULL worldmodel");
3666
3667         r_refdef.view.colorscale = r_hdr_scenebrightness.value;
3668
3669         // break apart the view matrix into vectors for various purposes
3670         // it is important that this occurs outside the RenderScene function because that can be called from reflection renders, where the vectors come out wrong
3671         // however the r_refdef.view.origin IS updated in RenderScene intentionally - otherwise the sky renders at the wrong origin, etc
3672         Matrix4x4_ToVectors(&r_refdef.view.matrix, r_refdef.view.forward, r_refdef.view.left, r_refdef.view.up, r_refdef.view.origin);
3673         VectorNegate(r_refdef.view.left, r_refdef.view.right);
3674         // make an inverted copy of the view matrix for tracking sprites
3675         Matrix4x4_Invert_Simple(&r_refdef.view.inverse_matrix, &r_refdef.view.matrix);
3676
3677         R_Shadow_UpdateWorldLightSelection();
3678
3679         R_Bloom_StartFrame();
3680         R_Water_StartFrame();
3681
3682         CHECKGLERROR
3683         if (r_timereport_active)
3684                 R_TimeReport("viewsetup");
3685
3686         R_ResetViewRendering3D();
3687
3688         if (r_refdef.view.clear || r_refdef.fogenabled)
3689         {
3690                 R_ClearScreen(r_refdef.fogenabled);
3691                 if (r_timereport_active)
3692                         R_TimeReport("viewclear");
3693         }
3694         r_refdef.view.clear = true;
3695
3696         r_refdef.view.showdebug = true;
3697
3698         // this produces a bloom texture to be used in R_BlendView() later
3699         if (r_hdr.integer)
3700                 R_HDR_RenderBloomTexture();
3701
3702         r_waterstate.numwaterplanes = 0;
3703         R_RenderScene(r_waterstate.enabled);
3704
3705         R_BlendView();
3706         if (r_timereport_active)
3707                 R_TimeReport("blendview");
3708
3709         GL_Scissor(0, 0, vid.width, vid.height);
3710         GL_ScissorTest(false);
3711         CHECKGLERROR
3712 }
3713
3714 extern void R_DrawLightningBeams (void);
3715 extern void VM_CL_AddPolygonsToMeshQueue (void);
3716 extern void R_DrawPortals (void);
3717 extern cvar_t cl_locs_show;
3718 static void R_DrawLocs(void);
3719 static void R_DrawEntityBBoxes(void);
3720 void R_RenderScene(qboolean addwaterplanes)
3721 {
3722         r_refdef.stats.renders++;
3723
3724         R_UpdateFogColor();
3725
3726         if (addwaterplanes)
3727         {
3728                 R_ResetViewRendering3D();
3729
3730                 R_View_Update();
3731                 if (r_timereport_active)
3732                         R_TimeReport("watervis");
3733
3734                 if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawAddWaterPlanes)
3735                 {
3736                         r_refdef.scene.worldmodel->DrawAddWaterPlanes(r_refdef.scene.worldentity);
3737                         if (r_timereport_active)
3738                                 R_TimeReport("waterworld");
3739                 }
3740
3741                 // don't let sound skip if going slow
3742                 if (r_refdef.scene.extraupdate)
3743                         S_ExtraUpdate ();
3744
3745                 R_DrawModelsAddWaterPlanes();
3746                 if (r_timereport_active)
3747                         R_TimeReport("watermodels");
3748
3749                 R_Water_ProcessPlanes();
3750                 if (r_timereport_active)
3751                         R_TimeReport("waterscenes");
3752         }
3753
3754         R_ResetViewRendering3D();
3755
3756         // don't let sound skip if going slow
3757         if (r_refdef.scene.extraupdate)
3758                 S_ExtraUpdate ();
3759
3760         R_MeshQueue_BeginScene();
3761
3762         R_SkyStartFrame();
3763
3764         R_View_Update();
3765         if (r_timereport_active)
3766                 R_TimeReport("visibility");
3767
3768         Matrix4x4_CreateTranslate(&r_waterscrollmatrix, sin(r_refdef.scene.time) * 0.025 * r_waterscroll.value, sin(r_refdef.scene.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
3769
3770         if (cl.csqc_vidvars.drawworld)
3771         {
3772                 // don't let sound skip if going slow
3773                 if (r_refdef.scene.extraupdate)
3774                         S_ExtraUpdate ();
3775
3776                 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawSky)
3777                 {
3778                         r_refdef.scene.worldmodel->DrawSky(r_refdef.scene.worldentity);
3779                         if (r_timereport_active)
3780                                 R_TimeReport("worldsky");
3781                 }
3782
3783                 if (R_DrawBrushModelsSky() && r_timereport_active)
3784                         R_TimeReport("bmodelsky");
3785         }
3786
3787         if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawDepth)
3788         {
3789                 r_refdef.scene.worldmodel->DrawDepth(r_refdef.scene.worldentity);
3790                 if (r_timereport_active)
3791                         R_TimeReport("worlddepth");
3792         }
3793         if (r_depthfirst.integer >= 2)
3794         {
3795                 R_DrawModelsDepth();
3796                 if (r_timereport_active)
3797                         R_TimeReport("modeldepth");
3798         }
3799
3800         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->Draw)
3801         {
3802                 r_refdef.scene.worldmodel->Draw(r_refdef.scene.worldentity);
3803                 if (r_timereport_active)
3804                         R_TimeReport("world");
3805         }
3806
3807         // don't let sound skip if going slow
3808         if (r_refdef.scene.extraupdate)
3809                 S_ExtraUpdate ();
3810
3811         R_DrawModels();
3812         if (r_timereport_active)
3813                 R_TimeReport("models");
3814
3815         // don't let sound skip if going slow
3816         if (r_refdef.scene.extraupdate)
3817                 S_ExtraUpdate ();
3818
3819         if (r_shadows.integer > 0 && r_refdef.lightmapintensity > 0)
3820         {
3821                 R_DrawModelShadows();
3822
3823                 R_ResetViewRendering3D();
3824
3825                 // don't let sound skip if going slow
3826                 if (r_refdef.scene.extraupdate)
3827                         S_ExtraUpdate ();
3828         }
3829
3830         R_ShadowVolumeLighting(false);
3831         if (r_timereport_active)
3832                 R_TimeReport("rtlights");
3833
3834         // don't let sound skip if going slow
3835         if (r_refdef.scene.extraupdate)
3836                 S_ExtraUpdate ();
3837
3838         if (cl.csqc_vidvars.drawworld)
3839         {
3840                 R_DrawLightningBeams();
3841                 if (r_timereport_active)
3842                         R_TimeReport("lightning");
3843
3844                 R_DrawDecals();
3845                 if (r_timereport_active)
3846                         R_TimeReport("decals");
3847
3848                 R_DrawParticles();
3849                 if (r_timereport_active)
3850                         R_TimeReport("particles");
3851
3852                 R_DrawExplosions();
3853                 if (r_timereport_active)
3854                         R_TimeReport("explosions");
3855         }
3856
3857         R_SetupGenericShader(true);
3858         VM_CL_AddPolygonsToMeshQueue();
3859
3860         if (r_refdef.view.showdebug)
3861         {
3862                 if (cl_locs_show.integer)
3863                 {
3864                         R_DrawLocs();
3865                         if (r_timereport_active)
3866                                 R_TimeReport("showlocs");
3867                 }
3868
3869                 if (r_drawportals.integer)
3870                 {
3871                         R_DrawPortals();
3872                         if (r_timereport_active)
3873                                 R_TimeReport("portals");
3874                 }
3875
3876                 if (r_showbboxes.value > 0)
3877                 {
3878                         R_DrawEntityBBoxes();
3879                         if (r_timereport_active)
3880                                 R_TimeReport("bboxes");
3881                 }
3882         }
3883
3884         R_SetupGenericShader(true);
3885         R_MeshQueue_RenderTransparent();
3886         if (r_timereport_active)
3887                 R_TimeReport("drawtrans");
3888
3889         R_SetupGenericShader(true);
3890
3891         if (r_refdef.view.showdebug && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawDebug && (r_showtris.value > 0 || r_shownormals.value > 0 || r_showcollisionbrushes.value > 0))
3892         {
3893                 r_refdef.scene.worldmodel->DrawDebug(r_refdef.scene.worldentity);
3894                 if (r_timereport_active)
3895                         R_TimeReport("worlddebug");
3896                 R_DrawModelsDebug();
3897                 if (r_timereport_active)
3898                         R_TimeReport("modeldebug");
3899         }
3900
3901         R_SetupGenericShader(true);
3902
3903         if (cl.csqc_vidvars.drawworld)
3904         {
3905                 R_DrawCoronas();
3906                 if (r_timereport_active)
3907                         R_TimeReport("coronas");
3908         }
3909
3910         // don't let sound skip if going slow
3911         if (r_refdef.scene.extraupdate)
3912                 S_ExtraUpdate ();
3913
3914         R_ResetViewRendering2D();
3915 }
3916
3917 static const int bboxelements[36] =
3918 {
3919         5, 1, 3, 5, 3, 7,
3920         6, 2, 0, 6, 0, 4,
3921         7, 3, 2, 7, 2, 6,
3922         4, 0, 1, 4, 1, 5,
3923         4, 5, 7, 4, 7, 6,
3924         1, 0, 2, 1, 2, 3,
3925 };
3926
3927 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
3928 {
3929         int i;
3930         float *v, *c, f1, f2, vertex3f[8*3], color4f[8*4];
3931         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3932         GL_DepthMask(false);
3933         GL_DepthRange(0, 1);
3934         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
3935         R_Mesh_Matrix(&identitymatrix);
3936         R_Mesh_ResetTextureState();
3937
3938         vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; //
3939         vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
3940         vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
3941         vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
3942         vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
3943         vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
3944         vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
3945         vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
3946         R_FillColors(color4f, 8, cr, cg, cb, ca);
3947         if (r_refdef.fogenabled)
3948         {
3949                 for (i = 0, v = vertex3f, c = color4f;i < 8;i++, v += 3, c += 4)
3950                 {
3951                         f1 = FogPoint_World(v);
3952                         f2 = 1 - f1;
3953                         c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
3954                         c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
3955                         c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
3956                 }
3957         }
3958         R_Mesh_VertexPointer(vertex3f, 0, 0);
3959         R_Mesh_ColorPointer(color4f, 0, 0);
3960         R_Mesh_ResetTextureState();
3961         R_SetupGenericShader(false);
3962         R_Mesh_Draw(0, 8, 12, bboxelements, 0, 0);
3963 }
3964
3965 static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
3966 {
3967         int i;
3968         float color[4];
3969         prvm_edict_t *edict;
3970         // this function draws bounding boxes of server entities
3971         if (!sv.active)
3972                 return;
3973         R_SetupGenericShader(false);
3974         SV_VM_Begin();
3975         for (i = 0;i < numsurfaces;i++)
3976         {
3977                 edict = PRVM_EDICT_NUM(surfacelist[i]);
3978                 switch ((int)edict->fields.server->solid)
3979                 {
3980                         case SOLID_NOT:      Vector4Set(color, 1, 1, 1, 0.05);break;
3981                         case SOLID_TRIGGER:  Vector4Set(color, 1, 0, 1, 0.10);break;
3982                         case SOLID_BBOX:     Vector4Set(color, 0, 1, 0, 0.10);break;
3983                         case SOLID_SLIDEBOX: Vector4Set(color, 1, 0, 0, 0.10);break;
3984                         case SOLID_BSP:      Vector4Set(color, 0, 0, 1, 0.05);break;
3985                         default:             Vector4Set(color, 0, 0, 0, 0.50);break;
3986                 }
3987                 color[3] *= r_showbboxes.value;
3988                 color[3] = bound(0, color[3], 1);
3989                 GL_DepthTest(!r_showdisabledepthtest.integer);
3990                 GL_CullFace(r_refdef.view.cullface_front);
3991                 R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
3992         }
3993         SV_VM_End();
3994 }
3995
3996 static void R_DrawEntityBBoxes(void)
3997 {
3998         int i;
3999         prvm_edict_t *edict;
4000         vec3_t center;
4001         // this function draws bounding boxes of server entities
4002         if (!sv.active)
4003                 return;
4004         SV_VM_Begin();
4005         for (i = 0;i < prog->num_edicts;i++)
4006         {
4007                 edict = PRVM_EDICT_NUM(i);
4008                 if (edict->priv.server->free)
4009                         continue;
4010                 VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
4011                 R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
4012         }
4013         SV_VM_End();
4014 }
4015
4016 int nomodelelements[24] =
4017 {
4018         5, 2, 0,
4019         5, 1, 2,
4020         5, 0, 3,
4021         5, 3, 1,
4022         0, 2, 4,
4023         2, 1, 4,
4024         3, 0, 4,
4025         1, 3, 4
4026 };
4027
4028 float nomodelvertex3f[6*3] =
4029 {
4030         -16,   0,   0,
4031          16,   0,   0,
4032           0, -16,   0,
4033           0,  16,   0,
4034           0,   0, -16,
4035           0,   0,  16
4036 };
4037
4038 float nomodelcolor4f[6*4] =
4039 {
4040         0.0f, 0.0f, 0.5f, 1.0f,
4041         0.0f, 0.0f, 0.5f, 1.0f,
4042         0.0f, 0.5f, 0.0f, 1.0f,
4043         0.0f, 0.5f, 0.0f, 1.0f,
4044         0.5f, 0.0f, 0.0f, 1.0f,
4045         0.5f, 0.0f, 0.0f, 1.0f
4046 };
4047
4048 void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
4049 {
4050         int i;
4051         float f1, f2, *c;
4052         float color4f[6*4];
4053         // this is only called once per entity so numsurfaces is always 1, and
4054         // surfacelist is always {0}, so this code does not handle batches
4055         R_Mesh_Matrix(&ent->matrix);
4056
4057         if (ent->flags & EF_ADDITIVE)
4058         {
4059                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
4060                 GL_DepthMask(false);
4061         }
4062         else if (ent->alpha < 1)
4063         {
4064                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
4065                 GL_DepthMask(false);
4066         }
4067         else
4068         {
4069                 GL_BlendFunc(GL_ONE, GL_ZERO);
4070                 GL_DepthMask(true);
4071         }
4072         GL_DepthRange(0, (ent->flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
4073         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
4074         GL_DepthTest(!(ent->effects & EF_NODEPTHTEST));
4075         GL_CullFace((ent->effects & EF_DOUBLESIDED) ? GL_NONE : r_refdef.view.cullface_back);
4076         R_SetupGenericShader(false);
4077         R_Mesh_VertexPointer(nomodelvertex3f, 0, 0);
4078         if (r_refdef.fogenabled)
4079         {
4080                 vec3_t org;
4081                 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
4082                 R_Mesh_ColorPointer(color4f, 0, 0);
4083                 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
4084                 f1 = FogPoint_World(org);
4085                 f2 = 1 - f1;
4086                 for (i = 0, c = color4f;i < 6;i++, c += 4)
4087                 {
4088                         c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
4089                         c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
4090                         c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
4091                         c[3] *= ent->alpha;
4092                 }
4093         }
4094         else if (ent->alpha != 1)
4095         {
4096                 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
4097                 R_Mesh_ColorPointer(color4f, 0, 0);
4098                 for (i = 0, c = color4f;i < 6;i++, c += 4)
4099                         c[3] *= ent->alpha;
4100         }
4101         else
4102                 R_Mesh_ColorPointer(nomodelcolor4f, 0, 0);
4103         R_Mesh_ResetTextureState();
4104         R_Mesh_Draw(0, 6, 8, nomodelelements, 0, 0);
4105 }
4106
4107 void R_DrawNoModel(entity_render_t *ent)
4108 {
4109         vec3_t org;
4110         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
4111         //if ((ent->effects & EF_ADDITIVE) || (ent->alpha < 1))
4112                 R_MeshQueue_AddTransparent(ent->effects & EF_NODEPTHTEST ? r_refdef.view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
4113         //else
4114         //      R_DrawNoModelCallback(ent, 0);
4115 }
4116
4117 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
4118 {
4119         vec3_t right1, right2, diff, normal;
4120
4121         VectorSubtract (org2, org1, normal);
4122
4123         // calculate 'right' vector for start
4124         VectorSubtract (r_refdef.view.origin, org1, diff);
4125         CrossProduct (normal, diff, right1);
4126         VectorNormalize (right1);
4127
4128         // calculate 'right' vector for end
4129         VectorSubtract (r_refdef.view.origin, org2, diff);
4130         CrossProduct (normal, diff, right2);
4131         VectorNormalize (right2);
4132
4133         vert[ 0] = org1[0] + width * right1[0];
4134         vert[ 1] = org1[1] + width * right1[1];
4135         vert[ 2] = org1[2] + width * right1[2];
4136         vert[ 3] = org1[0] - width * right1[0];
4137         vert[ 4] = org1[1] - width * right1[1];
4138         vert[ 5] = org1[2] - width * right1[2];
4139         vert[ 6] = org2[0] - width * right2[0];
4140         vert[ 7] = org2[1] - width * right2[1];
4141         vert[ 8] = org2[2] - width * right2[2];
4142         vert[ 9] = org2[0] + width * right2[0];
4143         vert[10] = org2[1] + width * right2[1];
4144         vert[11] = org2[2] + width * right2[2];
4145 }
4146
4147 float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
4148
4149 void R_DrawSprite(int blendfunc1, int blendfunc2, rtexture_t *texture, rtexture_t *fogtexture, qboolean depthdisable, qboolean depthshort, 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)
4150 {
4151         float fog = 1.0f;
4152         float vertex3f[12];
4153
4154         if (r_refdef.fogenabled && !depthdisable) // TODO maybe make the unfog effect a separate flag?
4155                 fog = FogPoint_World(origin);
4156
4157         R_Mesh_Matrix(&identitymatrix);
4158         GL_BlendFunc(blendfunc1, blendfunc2);
4159
4160         if(v_flipped_state)
4161         {
4162                 scalex1 = -scalex1;
4163                 scalex2 = -scalex2;
4164                 GL_CullFace(r_refdef.view.cullface_front);
4165         }
4166         else
4167                 GL_CullFace(r_refdef.view.cullface_back);
4168         GL_CullFace(GL_NONE);
4169
4170         GL_DepthMask(false);
4171         GL_DepthRange(0, depthshort ? 0.0625 : 1);
4172         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
4173         GL_DepthTest(!depthdisable);
4174
4175         vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
4176         vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
4177         vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
4178         vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
4179         vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
4180         vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
4181         vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
4182         vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
4183         vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
4184         vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
4185         vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
4186         vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
4187
4188         R_Mesh_VertexPointer(vertex3f, 0, 0);
4189         R_Mesh_ColorPointer(NULL, 0, 0);
4190         R_Mesh_ResetTextureState();
4191         R_SetupGenericShader(true);
4192         R_Mesh_TexBind(0, R_GetTexture(texture));
4193         R_Mesh_TexCoordPointer(0, 2, spritetexcoord2f, 0, 0);
4194         // FIXME: fixed function path can't properly handle r_refdef.view.colorscale > 1
4195         GL_Color(cr * fog * r_refdef.view.colorscale, cg * fog * r_refdef.view.colorscale, cb * fog * r_refdef.view.colorscale, ca);
4196         R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
4197
4198         if (blendfunc2 == GL_ONE_MINUS_SRC_ALPHA)
4199         {
4200                 R_Mesh_TexBind(0, R_GetTexture(fogtexture));
4201                 GL_BlendFunc(blendfunc1, GL_ONE);
4202                 fog = 1 - fog;
4203                 GL_Color(r_refdef.fogcolor[0] * fog, r_refdef.fogcolor[1] * fog, r_refdef.fogcolor[2] * fog, ca);
4204                 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
4205         }
4206 }
4207
4208 int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
4209 {
4210         int i;
4211         float *vertex3f;
4212         float v[3];
4213         VectorSet(v, x, y, z);
4214         for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
4215                 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
4216                         break;
4217         if (i == mesh->numvertices)
4218         {
4219                 if (mesh->numvertices < mesh->maxvertices)
4220                 {
4221                         VectorCopy(v, vertex3f);
4222                         mesh->numvertices++;
4223                 }
4224                 return mesh->numvertices;
4225         }
4226         else
4227                 return i;
4228 }
4229
4230 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
4231 {
4232         int i;
4233         int *e, element[3];
4234         element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
4235         element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
4236         e = mesh->element3i + mesh->numtriangles * 3;
4237         for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
4238         {
4239                 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
4240                 if (mesh->numtriangles < mesh->maxtriangles)
4241                 {
4242                         *e++ = element[0];
4243                         *e++ = element[1];
4244                         *e++ = element[2];
4245                         mesh->numtriangles++;
4246                 }
4247                 element[1] = element[2];
4248         }
4249 }
4250
4251 void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
4252 {
4253         int i;
4254         int *e, element[3];
4255         element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
4256         element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
4257         e = mesh->element3i + mesh->numtriangles * 3;
4258         for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
4259         {
4260                 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
4261                 if (mesh->numtriangles < mesh->maxtriangles)
4262                 {
4263                         *e++ = element[0];
4264                         *e++ = element[1];
4265                         *e++ = element[2];
4266                         mesh->numtriangles++;
4267                 }
4268                 element[1] = element[2];
4269         }
4270 }
4271
4272 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
4273 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
4274 {
4275         int planenum, planenum2;
4276         int w;
4277         int tempnumpoints;
4278         mplane_t *plane, *plane2;
4279         double maxdist;
4280         double temppoints[2][256*3];
4281         // figure out how large a bounding box we need to properly compute this brush
4282         maxdist = 0;
4283         for (w = 0;w < numplanes;w++)
4284                 maxdist = max(maxdist, planes[w].dist);
4285         // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
4286         maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
4287         for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
4288         {
4289                 w = 0;
4290                 tempnumpoints = 4;
4291                 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
4292                 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
4293                 {
4294                         if (planenum2 == planenum)
4295                                 continue;
4296                         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);
4297                         w = !w;
4298                 }
4299                 if (tempnumpoints < 3)
4300                         continue;
4301                 // generate elements forming a triangle fan for this polygon
4302                 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
4303         }
4304 }
4305
4306 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)
4307 {
4308         texturelayer_t *layer;
4309         layer = t->currentlayers + t->currentnumlayers++;
4310         layer->type = type;
4311         layer->depthmask = depthmask;
4312         layer->blendfunc1 = blendfunc1;
4313         layer->blendfunc2 = blendfunc2;
4314         layer->texture = texture;
4315         layer->texmatrix = *matrix;
4316         layer->color[0] = r * r_refdef.view.colorscale;
4317         layer->color[1] = g * r_refdef.view.colorscale;
4318         layer->color[2] = b * r_refdef.view.colorscale;
4319         layer->color[3] = a;
4320 }
4321
4322 static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
4323 {
4324         double index, f;
4325         index = parms[2] + r_refdef.scene.time * parms[3];
4326         index -= floor(index);
4327         switch (func)
4328         {
4329         default:
4330         case Q3WAVEFUNC_NONE:
4331         case Q3WAVEFUNC_NOISE:
4332         case Q3WAVEFUNC_COUNT:
4333                 f = 0;
4334                 break;
4335         case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
4336         case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
4337         case Q3WAVEFUNC_SAWTOOTH: f = index;break;
4338         case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
4339         case Q3WAVEFUNC_TRIANGLE:
4340                 index *= 4;
4341                 f = index - floor(index);
4342                 if (index < 1)
4343                         f = f;
4344                 else if (index < 2)
4345                         f = 1 - f;
4346                 else if (index < 3)
4347                         f = -f;
4348                 else
4349                         f = -(1 - f);
4350                 break;
4351         }
4352         return (float)(parms[0] + parms[1] * f);
4353 }
4354
4355 void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
4356 {
4357         int i;
4358         model_t *model = ent->model;
4359         float f;
4360         float tcmat[12];
4361         q3shaderinfo_layer_tcmod_t *tcmod;
4362
4363         // switch to an alternate material if this is a q1bsp animated material
4364         {
4365                 texture_t *texture = t;
4366                 int s = ent->skinnum;
4367                 if ((unsigned int)s >= (unsigned int)model->numskins)
4368                         s = 0;
4369                 if (model->skinscenes)
4370                 {
4371                         if (model->skinscenes[s].framecount > 1)
4372                                 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.scene.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
4373                         else
4374                                 s = model->skinscenes[s].firstframe;
4375                 }
4376                 if (s > 0)
4377                         t = t + s * model->num_surfaces;
4378                 if (t->animated)
4379                 {
4380                         // use an alternate animation if the entity's frame is not 0,
4381                         // and only if the texture has an alternate animation
4382                         if (ent->frame2 != 0 && t->anim_total[1])
4383                                 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[1]) : 0];
4384                         else
4385                                 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[0]) : 0];
4386                 }
4387                 texture->currentframe = t;
4388         }
4389
4390         // update currentskinframe to be a qw skin or animation frame
4391         if ((i = ent->entitynumber - 1) >= 0 && i < cl.maxclients)
4392         {
4393                 if (strcmp(r_qwskincache[i], cl.scores[i].qw_skin))
4394                 {
4395                         strlcpy(r_qwskincache[i], cl.scores[i].qw_skin, sizeof(r_qwskincache[i]));
4396                         Con_DPrintf("loading skins/%s\n", r_qwskincache[i]);
4397                         r_qwskincache_skinframe[i] = R_SkinFrame_LoadExternal(va("skins/%s", r_qwskincache[i]), TEXF_PRECACHE | (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_PICMIP | TEXF_COMPRESS, developer.integer > 0);
4398                 }
4399                 t->currentskinframe = r_qwskincache_skinframe[i];
4400                 if (t->currentskinframe == NULL)
4401                         t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - ent->frame2time)) % t->numskinframes];
4402         }
4403         else if (t->numskinframes >= 2)
4404                 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - ent->frame2time)) % t->numskinframes];
4405         if (t->backgroundnumskinframes >= 2)
4406                 t->backgroundcurrentskinframe = t->backgroundskinframes[(int)(t->backgroundskinframerate * (cl.time - ent->frame2time)) % t->backgroundnumskinframes];
4407
4408         t->currentmaterialflags = t->basematerialflags;
4409         t->currentalpha = ent->alpha;
4410         if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
4411         {
4412                 t->currentalpha *= r_wateralpha.value;
4413                 /*
4414                  * FIXME what is this supposed to do?
4415                 // if rendering refraction/reflection, disable transparency
4416                 if (r_waterstate.enabled && (t->currentalpha < 1 || (t->currentmaterialflags & MATERIALFLAG_ALPHA)))
4417                         t->currentmaterialflags |= MATERIALFLAG_WATERSHADER;
4418                 */
4419         }
4420         if(t->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled)
4421                 t->currentalpha *= t->r_water_wateralpha;
4422         if(!r_waterstate.enabled)
4423                 t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION);
4424         if (!(ent->flags & RENDER_LIGHT))
4425                 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
4426         else if (rsurface.modeltexcoordlightmap2f == NULL)
4427         {
4428                 // pick a model lighting mode
4429                 if (VectorLength2(ent->modellight_diffuse) >= (1.0f / 256.0f))
4430                         t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
4431                 else
4432                         t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
4433         }
4434         if (ent->effects & EF_ADDITIVE)
4435                 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
4436         else if (t->currentalpha < 1)
4437                 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
4438         if (ent->effects & EF_DOUBLESIDED)
4439                 t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
4440         if (ent->effects & EF_NODEPTHTEST)
4441                 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
4442         if (ent->flags & RENDER_VIEWMODEL)
4443                 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
4444         if (t->backgroundnumskinframes)
4445                 t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
4446         if (t->currentmaterialflags & MATERIALFLAG_BLENDED)
4447         {
4448                 if (t->currentmaterialflags & (MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER))
4449                         t->currentmaterialflags &= ~MATERIALFLAG_BLENDED;
4450         }
4451         else
4452                 t->currentmaterialflags &= ~(MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER);
4453
4454         // there is no tcmod
4455         if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
4456                 t->currenttexmatrix = r_waterscrollmatrix;
4457
4458         for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
4459         {
4460                 matrix4x4_t matrix;
4461                 switch(tcmod->tcmod)
4462                 {
4463                 case Q3TCMOD_COUNT:
4464                 case Q3TCMOD_NONE:
4465                         if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
4466                                 matrix = r_waterscrollmatrix;
4467                         else
4468                                 matrix = identitymatrix;
4469                         break;
4470                 case Q3TCMOD_ENTITYTRANSLATE:
4471                         // this is used in Q3 to allow the gamecode to control texcoord
4472                         // scrolling on the entity, which is not supported in darkplaces yet.
4473                         Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
4474                         break;
4475                 case Q3TCMOD_ROTATE:
4476                         Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
4477                         Matrix4x4_ConcatRotate(&matrix, tcmod->parms[0] * r_refdef.scene.time, 0, 0, 1);
4478                         Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
4479                         break;
4480                 case Q3TCMOD_SCALE:
4481                         Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
4482                         break;
4483                 case Q3TCMOD_SCROLL:
4484                         Matrix4x4_CreateTranslate(&matrix, tcmod->parms[0] * r_refdef.scene.time, tcmod->parms[1] * r_refdef.scene.time, 0);
4485                         break;
4486                 case Q3TCMOD_STRETCH:
4487                         f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
4488                         Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
4489                         break;
4490                 case Q3TCMOD_TRANSFORM:
4491                         VectorSet(tcmat +  0, tcmod->parms[0], tcmod->parms[1], 0);
4492                         VectorSet(tcmat +  3, tcmod->parms[2], tcmod->parms[3], 0);
4493                         VectorSet(tcmat +  6, 0                   , 0                , 1);
4494                         VectorSet(tcmat +  9, tcmod->parms[4], tcmod->parms[5], 0);
4495                         Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
4496                         break;
4497                 case Q3TCMOD_TURBULENT:
4498                         // this is handled in the RSurf_PrepareVertices function
4499                         matrix = identitymatrix;
4500                         break;
4501                 }
4502                 // either replace or concatenate the transformation
4503                 if (i < 1)
4504                         t->currenttexmatrix = matrix;
4505                 else
4506                 {
4507                         matrix4x4_t temp = t->currenttexmatrix;
4508                         Matrix4x4_Concat(&t->currenttexmatrix, &matrix, &temp);
4509                 }
4510         }
4511
4512         t->colormapping = VectorLength2(ent->colormap_pantscolor) + VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f);
4513         t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
4514         t->glosstexture = r_texture_black;
4515         t->backgroundbasetexture = t->backgroundnumskinframes ? ((!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base) : r_texture_white;
4516         t->backgroundglosstexture = r_texture_black;
4517         t->specularpower = r_shadow_glossexponent.value;
4518         // TODO: store reference values for these in the texture?
4519         t->specularscale = 0;
4520         if (r_shadow_gloss.integer > 0)
4521         {
4522                 if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
4523                 {
4524                         if (r_shadow_glossintensity.value > 0)
4525                         {
4526                                 t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
4527                                 t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
4528                                 t->specularscale = r_shadow_glossintensity.value;
4529                         }
4530                 }
4531                 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
4532                 {
4533                         t->glosstexture = r_texture_white;
4534                         t->backgroundglosstexture = r_texture_white;
4535                         t->specularscale = r_shadow_gloss2intensity.value;
4536                 }
4537         }
4538
4539         // lightmaps mode looks bad with dlights using actual texturing, so turn
4540         // off the colormap and glossmap, but leave the normalmap on as it still
4541         // accurately represents the shading involved
4542         if (gl_lightmaps.integer)
4543         {
4544                 t->basetexture = r_texture_grey128;
4545                 t->backgroundbasetexture = NULL;
4546                 t->specularscale = 0;
4547                 t->currentmaterialflags &= ~(MATERIALFLAG_ALPHA | MATERIALFLAG_ADD | MATERIALFLAG_WATERALPHA | MATERIALFLAG_WATER | MATERIALFLAG_SKY | MATERIALFLAG_ALPHATEST | MATERIALFLAG_BLENDED | MATERIALFLAG_CUSTOMBLEND | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION);
4548                 t->currentmaterialflags |= MATERIALFLAG_WALL;
4549         }
4550
4551         Vector4Set(t->lightmapcolor, ent->colormod[0], ent->colormod[1], ent->colormod[2], t->currentalpha);
4552         VectorClear(t->dlightcolor);
4553         t->currentnumlayers = 0;
4554         if (!(t->currentmaterialflags & MATERIALFLAG_NODRAW))
4555         {
4556                 if (!(t->currentmaterialflags & MATERIALFLAG_SKY))
4557                 {
4558                         int blendfunc1, blendfunc2, depthmask;
4559                         if (t->currentmaterialflags & MATERIALFLAG_ADD)
4560                         {
4561                                 blendfunc1 = GL_SRC_ALPHA;
4562                                 blendfunc2 = GL_ONE;
4563                         }
4564                         else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
4565                         {
4566                                 blendfunc1 = GL_SRC_ALPHA;
4567                                 blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
4568                         }
4569                         else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
4570                         {
4571                                 blendfunc1 = t->customblendfunc[0];
4572                                 blendfunc2 = t->customblendfunc[1];
4573                         }
4574                         else
4575                         {
4576                                 blendfunc1 = GL_ONE;
4577                                 blendfunc2 = GL_ZERO;
4578                         }
4579                         depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
4580                         if (t->currentmaterialflags & (MATERIALFLAG_WATER | MATERIALFLAG_WALL))
4581                         {
4582                                 int layerflags = 0;
4583                                 if (r_refdef.fogenabled && (t->currentmaterialflags & MATERIALFLAG_BLENDED))
4584                                         layerflags |= TEXTURELAYERFLAG_FOGDARKEN;
4585                                 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
4586                                 {
4587                                         // fullbright is not affected by r_refdef.lightmapintensity
4588                                         R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_TEXTURE, t->basetexture, &t->currenttexmatrix, t->lightmapcolor[0], t->lightmapcolor[1], t->lightmapcolor[2], t->lightmapcolor[3]);
4589                                         if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->currentskinframe->pants)
4590                                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->pants, &t->currenttexmatrix, ent->colormap_pantscolor[0] * t->lightmapcolor[0], ent->colormap_pantscolor[1] * t->lightmapcolor[1], ent->colormap_pantscolor[2] * t->lightmapcolor[2], t->lightmapcolor[3]);
4591                                         if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->currentskinframe->shirt)
4592                                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->shirt, &t->currenttexmatrix, ent->colormap_shirtcolor[0] * t->lightmapcolor[0], ent->colormap_shirtcolor[1] * t->lightmapcolor[1], ent->colormap_shirtcolor[2] * t->lightmapcolor[2], t->lightmapcolor[3]);
4593                                 }
4594                                 else
4595                                 {
4596                                         vec3_t ambientcolor;
4597                                         float colorscale;
4598                                         // set the color tint used for lights affecting this surface
4599                                         VectorSet(t->dlightcolor, ent->colormod[0] * t->lightmapcolor[3], ent->colormod[1] * t->lightmapcolor[3], ent->colormod[2] * t->lightmapcolor[3]);
4600                                         colorscale = 2;
4601                                         // q3bsp has no lightmap updates, so the lightstylevalue that
4602                                         // would normally be baked into the lightmap must be
4603                                         // applied to the color
4604                                         // FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
4605                                         if (ent->model->type == mod_brushq3)
4606                                                 colorscale *= r_refdef.scene.rtlightstylevalue[0];
4607                                         colorscale *= r_refdef.lightmapintensity;
4608                                         VectorScale(t->lightmapcolor, r_ambient.value * (1.0f / 64.0f), ambientcolor);
4609                                         VectorScale(t->lightmapcolor, colorscale, t->lightmapcolor);
4610                                         // basic lit geometry
4611                                         R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_LITTEXTURE, t->basetexture, &t->currenttexmatrix, t->lightmapcolor[0], t->lightmapcolor[1], t->lightmapcolor[2], t->lightmapcolor[3]);
4612                                         // add pants/shirt if needed
4613                                         if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->currentskinframe->pants)
4614                                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->currentskinframe->pants, &t->currenttexmatrix, ent->colormap_pantscolor[0] * t->lightmapcolor[0], ent->colormap_pantscolor[1] * t->lightmapcolor[1], ent->colormap_pantscolor[2]  * t->lightmapcolor[2], t->lightmapcolor[3]);
4615                                         if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->currentskinframe->shirt)
4616                                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->currentskinframe->shirt, &t->currenttexmatrix, ent->colormap_shirtcolor[0] * t->lightmapcolor[0], ent->colormap_shirtcolor[1] * t->lightmapcolor[1], ent->colormap_shirtcolor[2] * t->lightmapcolor[2], t->lightmapcolor[3]);
4617                                         // now add ambient passes if needed
4618                                         if (VectorLength2(ambientcolor) >= (1.0f/1048576.0f))
4619                                         {
4620                                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->basetexture, &t->currenttexmatrix, ambientcolor[0], ambientcolor[1], ambientcolor[2], t->lightmapcolor[3]);
4621                                                 if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->currentskinframe->pants)
4622                                                         R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->pants, &t->currenttexmatrix, ent->colormap_pantscolor[0] * ambientcolor[0], ent->colormap_pantscolor[1] * ambientcolor[1], ent->colormap_pantscolor[2] * ambientcolor[2], t->lightmapcolor[3]);
4623                                                 if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->currentskinframe->shirt)
4624                                                         R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->shirt, &t->currenttexmatrix, ent->colormap_shirtcolor[0] * ambientcolor[0], ent->colormap_shirtcolor[1] * ambientcolor[1], ent->colormap_shirtcolor[2] * ambientcolor[2], t->lightmapcolor[3]);
4625                                         }
4626                                 }
4627                                 if (t->currentskinframe->glow != NULL && !gl_lightmaps.integer)
4628                                         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->lightmapcolor[3]);
4629                                 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
4630                                 {
4631                                         // if this is opaque use alpha blend which will darken the earlier
4632                                         // passes cheaply.
4633                                         //
4634                                         // if this is an alpha blended material, all the earlier passes
4635                                         // were darkened by fog already, so we only need to add the fog
4636                                         // color ontop through the fog mask texture
4637                                         //
4638                                         // if this is an additive blended material, all the earlier passes
4639                                         // were darkened by fog already, and we should not add fog color
4640                                         // (because the background was not darkened, there is no fog color
4641                                         // that was lost behind it).
4642                                         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.view.colorscale, r_refdef.fogcolor[1] / r_refdef.view.colorscale, r_refdef.fogcolor[2] / r_refdef.view.colorscale, t->lightmapcolor[3]);
4643                                 }
4644                         }
4645                 }
4646         }
4647 }
4648
4649 void R_UpdateAllTextureInfo(entity_render_t *ent)
4650 {
4651         int i;
4652         if (ent->model)
4653                 for (i = 0;i < ent->model->num_texturesperskin;i++)
4654                         R_UpdateTextureInfo(ent, ent->model->data_textures + i);
4655 }
4656
4657 rsurfacestate_t rsurface;
4658
4659 void R_Mesh_ResizeArrays(int newvertices)
4660 {
4661         float *base;
4662         if (rsurface.array_size >= newvertices)
4663                 return;
4664         if (rsurface.array_modelvertex3f)
4665                 Mem_Free(rsurface.array_modelvertex3f);
4666         rsurface.array_size = (newvertices + 1023) & ~1023;
4667         base = (float *)Mem_Alloc(r_main_mempool, rsurface.array_size * sizeof(float[33]));
4668         rsurface.array_modelvertex3f     = base + rsurface.array_size * 0;
4669         rsurface.array_modelsvector3f    = base + rsurface.array_size * 3;
4670         rsurface.array_modeltvector3f    = base + rsurface.array_size * 6;
4671         rsurface.array_modelnormal3f     = base + rsurface.array_size * 9;
4672         rsurface.array_deformedvertex3f  = base + rsurface.array_size * 12;
4673         rsurface.array_deformedsvector3f = base + rsurface.array_size * 15;
4674         rsurface.array_deformedtvector3f = base + rsurface.array_size * 18;
4675         rsurface.array_deformednormal3f  = base + rsurface.array_size * 21;
4676         rsurface.array_texcoord3f        = base + rsurface.array_size * 24;
4677         rsurface.array_color4f           = base + rsurface.array_size * 27;
4678         rsurface.array_generatedtexcoordtexture2f = base + rsurface.array_size * 31;
4679 }
4680
4681 void RSurf_ActiveWorldEntity(void)
4682 {
4683         model_t *model = r_refdef.scene.worldmodel;
4684         if (rsurface.array_size < model->surfmesh.num_vertices)
4685                 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
4686         rsurface.matrix = identitymatrix;
4687         rsurface.inversematrix = identitymatrix;
4688         R_Mesh_Matrix(&identitymatrix);
4689         VectorCopy(r_refdef.view.origin, rsurface.modelorg);
4690         VectorSet(rsurface.modellight_ambient, 0, 0, 0);
4691         VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
4692         VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
4693         VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
4694         VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
4695         rsurface.frameblend[0].frame = 0;
4696         rsurface.frameblend[0].lerp = 1;
4697         rsurface.frameblend[1].frame = 0;
4698         rsurface.frameblend[1].lerp = 0;
4699         rsurface.frameblend[2].frame = 0;
4700         rsurface.frameblend[2].lerp = 0;
4701         rsurface.frameblend[3].frame = 0;
4702         rsurface.frameblend[3].lerp = 0;
4703         rsurface.basepolygonfactor = r_refdef.polygonfactor;
4704         rsurface.basepolygonoffset = r_refdef.polygonoffset;
4705         rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
4706         rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
4707         rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
4708         rsurface.modelsvector3f = model->surfmesh.data_svector3f;
4709         rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
4710         rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
4711         rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
4712         rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
4713         rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
4714         rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
4715         rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
4716         rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
4717         rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
4718         rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
4719         rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
4720         rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
4721         rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
4722         rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
4723         rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
4724         rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
4725         rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
4726         rsurface.modelelement3i = model->surfmesh.data_element3i;
4727         rsurface.modelelement3i_bufferobject = model->surfmesh.ebo;
4728         rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
4729         rsurface.modelnum_vertices = model->surfmesh.num_vertices;
4730         rsurface.modelnum_triangles = model->surfmesh.num_triangles;
4731         rsurface.modelsurfaces = model->data_surfaces;
4732         rsurface.generatedvertex = false;
4733         rsurface.vertex3f  = rsurface.modelvertex3f;
4734         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
4735         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
4736         rsurface.svector3f = rsurface.modelsvector3f;
4737         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
4738         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
4739         rsurface.tvector3f = rsurface.modeltvector3f;
4740         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
4741         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
4742         rsurface.normal3f  = rsurface.modelnormal3f;
4743         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
4744         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
4745         rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
4746 }
4747
4748 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
4749 {
4750         model_t *model = ent->model;
4751         if (rsurface.array_size < model->surfmesh.num_vertices)
4752                 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
4753         rsurface.matrix = ent->matrix;
4754         rsurface.inversematrix = ent->inversematrix;
4755         R_Mesh_Matrix(&rsurface.matrix);
4756         Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.modelorg);
4757         rsurface.modellight_ambient[0] = ent->modellight_ambient[0] * ent->colormod[0];
4758         rsurface.modellight_ambient[1] = ent->modellight_ambient[1] * ent->colormod[1];
4759         rsurface.modellight_ambient[2] = ent->modellight_ambient[2] * ent->colormod[2];
4760         rsurface.modellight_diffuse[0] = ent->modellight_diffuse[0] * ent->colormod[0];
4761         rsurface.modellight_diffuse[1] = ent->modellight_diffuse[1] * ent->colormod[1];
4762         rsurface.modellight_diffuse[2] = ent->modellight_diffuse[2] * ent->colormod[2];
4763         VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
4764         VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
4765         VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
4766         VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
4767         rsurface.frameblend[0] = ent->frameblend[0];
4768         rsurface.frameblend[1] = ent->frameblend[1];
4769         rsurface.frameblend[2] = ent->frameblend[2];
4770         rsurface.frameblend[3] = ent->frameblend[3];
4771         rsurface.basepolygonfactor = r_refdef.polygonfactor;
4772         rsurface.basepolygonoffset = r_refdef.polygonoffset;
4773         if (ent->model->brush.submodel)
4774         {
4775                 rsurface.basepolygonfactor += r_polygonoffset_submodel_factor.value;
4776                 rsurface.basepolygonoffset += r_polygonoffset_submodel_offset.value;
4777         }
4778         if (model->surfmesh.isanimated && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].frame != 0))
4779         {
4780                 if (wanttangents)
4781                 {
4782                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
4783                         rsurface.modelsvector3f = rsurface.array_modelsvector3f;
4784                         rsurface.modeltvector3f = rsurface.array_modeltvector3f;
4785                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
4786                         Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f);
4787                 }
4788                 else if (wantnormals)
4789                 {
4790                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
4791                         rsurface.modelsvector3f = NULL;
4792                         rsurface.modeltvector3f = NULL;
4793                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
4794                         Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL);
4795                 }
4796                 else
4797                 {
4798                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
4799                         rsurface.modelsvector3f = NULL;
4800                         rsurface.modeltvector3f = NULL;
4801                         rsurface.modelnormal3f = NULL;
4802                         Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, NULL, NULL, NULL);
4803                 }
4804                 rsurface.modelvertex3f_bufferobject = 0;
4805                 rsurface.modelvertex3f_bufferoffset = 0;
4806                 rsurface.modelsvector3f_bufferobject = 0;
4807                 rsurface.modelsvector3f_bufferoffset = 0;
4808                 rsurface.modeltvector3f_bufferobject = 0;
4809                 rsurface.modeltvector3f_bufferoffset = 0;
4810                 rsurface.modelnormal3f_bufferobject = 0;
4811                 rsurface.modelnormal3f_bufferoffset = 0;
4812                 rsurface.generatedvertex = true;
4813         }
4814         else
4815         {
4816                 rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
4817                 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
4818                 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
4819                 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
4820                 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
4821                 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
4822                 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
4823                 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
4824                 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
4825                 rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
4826                 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
4827                 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
4828                 rsurface.generatedvertex = false;
4829         }
4830         rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
4831         rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
4832         rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
4833         rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
4834         rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
4835         rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
4836         rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
4837         rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
4838         rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
4839         rsurface.modelelement3i = model->surfmesh.data_element3i;
4840         rsurface.modelelement3i_bufferobject = model->surfmesh.ebo;
4841         rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
4842         rsurface.modelnum_vertices = model->surfmesh.num_vertices;
4843         rsurface.modelnum_triangles = model->surfmesh.num_triangles;
4844         rsurface.modelsurfaces = model->data_surfaces;
4845         rsurface.vertex3f  = rsurface.modelvertex3f;
4846         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
4847         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
4848         rsurface.svector3f = rsurface.modelsvector3f;
4849         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
4850         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
4851         rsurface.tvector3f = rsurface.modeltvector3f;
4852         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
4853         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
4854         rsurface.normal3f  = rsurface.modelnormal3f;
4855         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
4856         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
4857         rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
4858 }
4859
4860 static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
4861 void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, msurface_t **texturesurfacelist)
4862 {
4863         int deformindex;
4864         int texturesurfaceindex;
4865         int i, j;
4866         float amplitude;
4867         float animpos;
4868         float scale;
4869         const float *v1, *in_tc;
4870         float *out_tc;
4871         float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
4872         float waveparms[4];
4873         q3shaderinfo_deform_t *deform;
4874         // 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
4875         if (rsurface.generatedvertex)
4876         {
4877                 if (rsurface.texture->tcgen.tcgen == Q3TCGEN_ENVIRONMENT)
4878                         generatenormals = true;
4879                 for (i = 0;i < Q3MAXDEFORMS;i++)
4880                 {
4881                         if (rsurface.texture->deforms[i].deform == Q3DEFORM_AUTOSPRITE)
4882                         {
4883                                 generatetangents = true;
4884                                 generatenormals = true;
4885                         }
4886                         if (rsurface.texture->deforms[i].deform != Q3DEFORM_NONE)
4887                                 generatenormals = true;
4888                 }
4889                 if (generatenormals && !rsurface.modelnormal3f)
4890                 {
4891                         rsurface.normal3f = rsurface.modelnormal3f = rsurface.array_modelnormal3f;
4892                         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject = 0;
4893                         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset = 0;
4894                         Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer);
4895                 }
4896                 if (generatetangents && !rsurface.modelsvector3f)
4897                 {
4898                         rsurface.svector3f = rsurface.modelsvector3f = rsurface.array_modelsvector3f;
4899                         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject = 0;
4900                         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset = 0;
4901                         rsurface.tvector3f = rsurface.modeltvector3f = rsurface.array_modeltvector3f;
4902                         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject = 0;
4903                         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset = 0;
4904                         Mod_BuildTextureVectorsFromNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modeltexcoordtexture2f, rsurface.modelnormal3f, rsurface.modelelement3i, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f, r_smoothnormals_areaweighting.integer);
4905                 }
4906         }
4907         rsurface.vertex3f  = rsurface.modelvertex3f;
4908         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
4909         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
4910         rsurface.svector3f = rsurface.modelsvector3f;
4911         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
4912         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
4913         rsurface.tvector3f = rsurface.modeltvector3f;
4914         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
4915         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
4916         rsurface.normal3f  = rsurface.modelnormal3f;
4917         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
4918         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
4919         // if vertices are deformed (sprite flares and things in maps, possibly
4920         // water waves, bulges and other deformations), generate them into
4921         // rsurface.deform* arrays from whatever the rsurface.* arrays point to
4922         // (may be static model data or generated data for an animated model, or
4923         //  the previous deform pass)
4924         for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
4925         {
4926                 switch (deform->deform)
4927                 {
4928                 default:
4929                 case Q3DEFORM_PROJECTIONSHADOW:
4930                 case Q3DEFORM_TEXT0:
4931                 case Q3DEFORM_TEXT1:
4932                 case Q3DEFORM_TEXT2:
4933                 case Q3DEFORM_TEXT3:
4934                 case Q3DEFORM_TEXT4:
4935                 case Q3DEFORM_TEXT5:
4936                 case Q3DEFORM_TEXT6:
4937                 case Q3DEFORM_TEXT7:
4938                 case Q3DEFORM_NONE:
4939                         break;
4940                 case Q3DEFORM_AUTOSPRITE:
4941                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
4942                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
4943                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
4944                         VectorNormalize(newforward);
4945                         VectorNormalize(newright);
4946                         VectorNormalize(newup);
4947                         // make deformed versions of only the model vertices used by the specified surfaces
4948                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4949                         {
4950                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4951                                 // a single autosprite surface can contain multiple sprites...
4952                                 for (j = 0;j < surface->num_vertices - 3;j += 4)
4953                                 {
4954                                         VectorClear(center);
4955                                         for (i = 0;i < 4;i++)
4956                                                 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
4957                                         VectorScale(center, 0.25f, center);
4958                                         VectorCopy((rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, forward);
4959                                         VectorCopy((rsurface.svector3f + 3 * surface->num_firstvertex) + j*3, right);
4960                                         VectorCopy((rsurface.tvector3f + 3 * surface->num_firstvertex) + j*3, up);
4961                                         for (i = 0;i < 4;i++)
4962                                         {
4963                                                 VectorSubtract((rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, center, v);
4964                                                 VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
4965                                         }
4966                                 }
4967                                 Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformednormal3f, r_smoothnormals_areaweighting.integer);
4968                                 Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer);
4969                         }
4970                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
4971                         rsurface.vertex3f_bufferobject = 0;
4972                         rsurface.vertex3f_bufferoffset = 0;
4973                         rsurface.svector3f = rsurface.array_deformedsvector3f;
4974                         rsurface.svector3f_bufferobject = 0;
4975                         rsurface.svector3f_bufferoffset = 0;
4976                         rsurface.tvector3f = rsurface.array_deformedtvector3f;
4977                         rsurface.tvector3f_bufferobject = 0;
4978                         rsurface.tvector3f_bufferoffset = 0;
4979                         rsurface.normal3f = rsurface.array_deformednormal3f;
4980                         rsurface.normal3f_bufferobject = 0;
4981                         rsurface.normal3f_bufferoffset = 0;
4982                         break;
4983                 case Q3DEFORM_AUTOSPRITE2:
4984                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
4985                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
4986                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
4987                         VectorNormalize(newforward);
4988                         VectorNormalize(newright);
4989                         VectorNormalize(newup);
4990                         // make deformed versions of only the model vertices used by the specified surfaces
4991                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4992                         {
4993                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4994                                 const float *v1, *v2;
4995                                 vec3_t start, end;
4996                                 float f, l;
4997                                 struct
4998                                 {
4999                                         float length2;
5000                                         const float *v1;
5001                                         const float *v2;
5002                                 }
5003                                 shortest[2];
5004                                 memset(shortest, 0, sizeof(shortest));
5005                                 // a single autosprite surface can contain multiple sprites...
5006                                 for (j = 0;j < surface->num_vertices - 3;j += 4)
5007                                 {
5008                                         VectorClear(center);
5009                                         for (i = 0;i < 4;i++)
5010                                                 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
5011                                         VectorScale(center, 0.25f, center);
5012                                         // find the two shortest edges, then use them to define the
5013                                         // axis vectors for rotating around the central axis
5014                                         for (i = 0;i < 6;i++)
5015                                         {
5016                                                 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][0]);
5017                                                 v2 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][1]);
5018 #if 0
5019                                                 Debug_PolygonBegin(NULL, 0);
5020                                                 Debug_PolygonVertex(v1[0], v1[1], v1[2], 0, 0, 1, 0, 0, 1);
5021                                                 Debug_PolygonVertex((v1[0] + v2[0]) * 0.5f + rsurface.normal3f[3 * (surface->num_firstvertex + j)+0] * 4, (v1[1] + v2[1]) * 0.5f + rsurface.normal3f[3 * (surface->num_firstvertex + j)+1], (v1[2] + v2[2]) * 0.5f + rsurface.normal3f[3 * (surface->num_firstvertex + j)+2], 0, 0, 1, 1, 0, 1);
5022                                                 Debug_PolygonVertex(v2[0], v2[1], v2[2], 0, 0, 1, 0, 0, 1);
5023                                                 Debug_PolygonEnd();
5024 #endif
5025                                                 l = VectorDistance2(v1, v2);
5026                                                 // this length bias tries to make sense of square polygons, assuming they are meant to be upright
5027                                                 if (v1[2] != v2[2])
5028                                                         l += (1.0f / 1024.0f);
5029                                                 if (shortest[0].length2 > l || i == 0)
5030                                                 {
5031                                                         shortest[1] = shortest[0];
5032                                                         shortest[0].length2 = l;
5033                                                         shortest[0].v1 = v1;
5034                                                         shortest[0].v2 = v2;
5035                                                 }
5036                                                 else if (shortest[1].length2 > l || i == 1)
5037                                                 {
5038                                                         shortest[1].length2 = l;
5039                                                         shortest[1].v1 = v1;
5040                                                         shortest[1].v2 = v2;
5041                                                 }
5042                                         }
5043                                         VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
5044                                         VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
5045 #if 0
5046                                         Debug_PolygonBegin(NULL, 0);
5047                                         Debug_PolygonVertex(start[0], start[1], start[2], 0, 0, 1, 1, 0, 1);
5048                                         Debug_PolygonVertex(center[0] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+0] * 4, center[1] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+1] * 4, center[2] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+2] * 4, 0, 0, 0, 1, 0, 1);
5049                                         Debug_PolygonVertex(end[0], end[1], end[2], 0, 0, 0, 1, 1, 1);
5050                                         Debug_PolygonEnd();
5051 #endif
5052                                         // this calculates the right vector from the shortest edge
5053                                         // and the up vector from the edge midpoints
5054                                         VectorSubtract(shortest[0].v1, shortest[0].v2, right);
5055                                         VectorNormalize(right);
5056                                         VectorSubtract(end, start, up);
5057                                         VectorNormalize(up);
5058                                         // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
5059                                         //VectorSubtract(rsurface.modelorg, center, forward);
5060                                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, forward);
5061                                         VectorNegate(forward, forward);
5062                                         VectorReflect(forward, 0, up, forward);
5063                                         VectorNormalize(forward);
5064                                         CrossProduct(up, forward, newright);
5065                                         VectorNormalize(newright);
5066 #if 0
5067                                         Debug_PolygonBegin(NULL, 0);
5068                                         Debug_PolygonVertex(center[0] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+0] * 8, center[1] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+1] * 8, center[2] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+2] * 8, 0, 0, 1, 0, 0, 1);
5069                                         Debug_PolygonVertex(center[0] + right[0] * 8, center[1] + right[1] * 8, center[2] + right[2] * 8, 0, 0, 0, 1, 0, 1);
5070                                         Debug_PolygonVertex(center[0] + up   [0] * 8, center[1] + up   [1] * 8, center[2] + up   [2] * 8, 0, 0, 0, 0, 1, 1);
5071                                         Debug_PolygonEnd();
5072 #endif
5073 #if 0
5074                                         Debug_PolygonBegin(NULL, 0);
5075                                         Debug_PolygonVertex(center[0] + forward [0] * 8, center[1] + forward [1] * 8, center[2] + forward [2] * 8, 0, 0, 1, 0, 0, 1);
5076                                         Debug_PolygonVertex(center[0] + newright[0] * 8, center[1] + newright[1] * 8, center[2] + newright[2] * 8, 0, 0, 0, 1, 0, 1);
5077                                         Debug_PolygonVertex(center[0] + up      [0] * 8, center[1] + up      [1] * 8, center[2] + up      [2] * 8, 0, 0, 0, 0, 1, 1);
5078                                         Debug_PolygonEnd();
5079 #endif
5080                                         // rotate the quad around the up axis vector, this is made
5081                                         // especially easy by the fact we know the quad is flat,
5082                                         // so we only have to subtract the center position and
5083                                         // measure distance along the right vector, and then
5084                                         // multiply that by the newright vector and add back the
5085                                         // center position
5086                                         // we also need to subtract the old position to undo the
5087                                         // displacement from the center, which we do with a
5088                                         // DotProduct, the subtraction/addition of center is also
5089                                         // optimized into DotProducts here
5090                                         l = DotProduct(right, center);
5091                                         for (i = 0;i < 4;i++)
5092                                         {
5093                                                 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + j + i);
5094                                                 f = DotProduct(right, v1) - l;
5095                                                 VectorMAMAM(1, v1, -f, right, f, newright, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
5096                                         }
5097                                 }
5098                                 Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformednormal3f, r_smoothnormals_areaweighting.integer);
5099                                 Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer);
5100                         }
5101                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
5102                         rsurface.vertex3f_bufferobject = 0;
5103                         rsurface.vertex3f_bufferoffset = 0;
5104                         rsurface.svector3f = rsurface.array_deformedsvector3f;
5105                         rsurface.svector3f_bufferobject = 0;
5106                         rsurface.svector3f_bufferoffset = 0;
5107                         rsurface.tvector3f = rsurface.array_deformedtvector3f;
5108                         rsurface.tvector3f_bufferobject = 0;
5109                         rsurface.tvector3f_bufferoffset = 0;
5110                         rsurface.normal3f = rsurface.array_deformednormal3f;
5111                         rsurface.normal3f_bufferobject = 0;
5112                         rsurface.normal3f_bufferoffset = 0;
5113                         break;
5114                 case Q3DEFORM_NORMAL:
5115                         // deform the normals to make reflections wavey
5116                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5117                         {
5118                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5119                                 for (j = 0;j < surface->num_vertices;j++)
5120                                 {
5121                                         float vertex[3];
5122                                         float *normal = (rsurface.array_deformednormal3f  + 3 * surface->num_firstvertex) + j*3;
5123                                         VectorScale((rsurface.vertex3f  + 3 * surface->num_firstvertex) + j*3, 0.98f, vertex);
5124                                         VectorCopy((rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, normal);
5125                                         normal[0] += deform->parms[0] * noise4f(      vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
5126                                         normal[1] += deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
5127                                         normal[2] += deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
5128                                         VectorNormalize(normal);
5129                                 }
5130                                 Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer);
5131                         }
5132                         rsurface.svector3f = rsurface.array_deformedsvector3f;
5133                         rsurface.svector3f_bufferobject = 0;
5134                         rsurface.svector3f_bufferoffset = 0;
5135                         rsurface.tvector3f = rsurface.array_deformedtvector3f;
5136                         rsurface.tvector3f_bufferobject = 0;
5137                         rsurface.tvector3f_bufferoffset = 0;
5138                         rsurface.normal3f = rsurface.array_deformednormal3f;
5139                         rsurface.normal3f_bufferobject = 0;
5140                         rsurface.normal3f_bufferoffset = 0;
5141                         break;
5142                 case Q3DEFORM_WAVE:
5143                         // deform vertex array to make wavey water and flags and such
5144                         waveparms[0] = deform->waveparms[0];
5145                         waveparms[1] = deform->waveparms[1];
5146                         waveparms[2] = deform->waveparms[2];
5147                         waveparms[3] = deform->waveparms[3];
5148                         // this is how a divisor of vertex influence on deformation
5149                         animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
5150                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
5151                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5152                         {
5153                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5154                                 for (j = 0;j < surface->num_vertices;j++)
5155                                 {
5156                                         float *vertex = (rsurface.array_deformedvertex3f  + 3 * surface->num_firstvertex) + j*3;
5157                                         VectorCopy((rsurface.vertex3f  + 3 * surface->num_firstvertex) + j*3, vertex);
5158                                         // if the wavefunc depends on time, evaluate it per-vertex
5159                                         if (waveparms[3])
5160                                         {
5161                                                 waveparms[2] = deform->waveparms[2] + (vertex[0] + vertex[1] + vertex[2]) * animpos;
5162                                                 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
5163                                         }
5164                                         VectorMA(vertex, scale, (rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, vertex);
5165                                 }
5166                         }
5167                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
5168                         rsurface.vertex3f_bufferobject = 0;
5169                         rsurface.vertex3f_bufferoffset = 0;
5170                         break;
5171                 case Q3DEFORM_BULGE:
5172                         // deform vertex array to make the surface have moving bulges
5173                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5174                         {
5175                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5176                                 for (j = 0;j < surface->num_vertices;j++)
5177                                 {
5178                                         scale = sin((rsurface.modeltexcoordtexture2f[2 * (surface->num_firstvertex + j)] * deform->parms[0] + r_refdef.scene.time * deform->parms[2])) * deform->parms[1];
5179                                         VectorMA(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), scale, rsurface.normal3f + 3 * (surface->num_firstvertex + j), rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
5180                                 }
5181                         }
5182                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
5183                         rsurface.vertex3f_bufferobject = 0;
5184                         rsurface.vertex3f_bufferoffset = 0;
5185                         break;
5186                 case Q3DEFORM_MOVE:
5187                         // deform vertex array
5188                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
5189                         VectorScale(deform->parms, scale, waveparms);
5190                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5191                         {
5192                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5193                                 for (j = 0;j < surface->num_vertices;j++)
5194                                         VectorAdd(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), waveparms, rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
5195                         }
5196                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
5197                         rsurface.vertex3f_bufferobject = 0;
5198                         rsurface.vertex3f_bufferoffset = 0;
5199                         break;
5200                 }
5201         }
5202         // generate texcoords based on the chosen texcoord source
5203         switch(rsurface.texture->tcgen.tcgen)
5204         {
5205         default:
5206         case Q3TCGEN_TEXTURE:
5207                 rsurface.texcoordtexture2f               = rsurface.modeltexcoordtexture2f;
5208                 rsurface.texcoordtexture2f_bufferobject  = rsurface.modeltexcoordtexture2f_bufferobject;
5209                 rsurface.texcoordtexture2f_bufferoffset  = rsurface.modeltexcoordtexture2f_bufferoffset;
5210                 break;
5211         case Q3TCGEN_LIGHTMAP:
5212                 rsurface.texcoordtexture2f               = rsurface.modeltexcoordlightmap2f;
5213                 rsurface.texcoordtexture2f_bufferobject  = rsurface.modeltexcoordlightmap2f_bufferobject;
5214                 rsurface.texcoordtexture2f_bufferoffset  = rsurface.modeltexcoordlightmap2f_bufferoffset;
5215                 break;
5216         case Q3TCGEN_VECTOR:
5217                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5218                 {
5219                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5220                         for (j = 0, v1 = rsurface.modelvertex3f + 3 * surface->num_firstvertex, out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;j < surface->num_vertices;j++, v1 += 3, out_tc += 2)
5221                         {
5222                                 out_tc[0] = DotProduct(v1, rsurface.texture->tcgen.parms);
5223                                 out_tc[1] = DotProduct(v1, rsurface.texture->tcgen.parms + 3);
5224                         }
5225                 }
5226                 rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
5227                 rsurface.texcoordtexture2f_bufferobject  = 0;
5228                 rsurface.texcoordtexture2f_bufferoffset  = 0;
5229                 break;
5230         case Q3TCGEN_ENVIRONMENT:
5231                 // make environment reflections using a spheremap
5232                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5233                 {
5234                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5235                         const float *vertex = rsurface.modelvertex3f + 3 * surface->num_firstvertex;
5236                         const float *normal = rsurface.modelnormal3f + 3 * surface->num_firstvertex;
5237                         float *out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;
5238                         for (j = 0;j < surface->num_vertices;j++, vertex += 3, normal += 3, out_tc += 2)
5239                         {
5240                                 float l, d, eyedir[3];
5241                                 VectorSubtract(rsurface.modelorg, vertex, eyedir);
5242                                 l = 0.5f / VectorLength(eyedir);
5243                                 d = DotProduct(normal, eyedir)*2;
5244                                 out_tc[0] = 0.5f + (normal[1]*d - eyedir[1])*l;
5245                                 out_tc[1] = 0.5f - (normal[2]*d - eyedir[2])*l;
5246                         }
5247                 }
5248                 rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
5249                 rsurface.texcoordtexture2f_bufferobject  = 0;
5250                 rsurface.texcoordtexture2f_bufferoffset  = 0;
5251                 break;
5252         }
5253         // the only tcmod that needs software vertex processing is turbulent, so
5254         // check for it here and apply the changes if needed
5255         // and we only support that as the first one
5256         // (handling a mixture of turbulent and other tcmods would be problematic
5257         //  without punting it entirely to a software path)
5258         if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
5259         {
5260                 amplitude = rsurface.texture->tcmods[0].parms[1];
5261                 animpos = rsurface.texture->tcmods[0].parms[2] + r_refdef.scene.time * rsurface.texture->tcmods[0].parms[3];
5262                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5263                 {
5264                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5265                         for (j = 0, v1 = rsurface.modelvertex3f + 3 * surface->num_firstvertex, in_tc = rsurface.texcoordtexture2f + 2 * surface->num_firstvertex, out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;j < surface->num_vertices;j++, v1 += 3, in_tc += 2, out_tc += 2)
5266                         {
5267                                 out_tc[0] = in_tc[0] + amplitude * sin(((v1[0] + v1[2]) * 1.0 / 1024.0f + animpos) * M_PI * 2);
5268                                 out_tc[1] = in_tc[1] + amplitude * sin(((v1[1]        ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
5269                         }
5270                 }
5271                 rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
5272                 rsurface.texcoordtexture2f_bufferobject  = 0;
5273                 rsurface.texcoordtexture2f_bufferoffset  = 0;
5274         }
5275         rsurface.texcoordlightmap2f              = rsurface.modeltexcoordlightmap2f;
5276         rsurface.texcoordlightmap2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
5277         rsurface.texcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
5278         R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
5279 }
5280
5281 void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacelist)
5282 {
5283         int i, j;
5284         const msurface_t *surface = texturesurfacelist[0];
5285         const msurface_t *surface2;
5286         int firstvertex;
5287         int endvertex;
5288         int numvertices;
5289         int numtriangles;
5290         // TODO: lock all array ranges before render, rather than on each surface
5291         if (texturenumsurfaces == 1)
5292         {
5293                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5294                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5295         }
5296         else if (r_batchmode.integer == 2)
5297         {
5298                 #define MAXBATCHTRIANGLES 4096
5299                 int batchtriangles = 0;
5300                 int batchelements[MAXBATCHTRIANGLES*3];
5301                 for (i = 0;i < texturenumsurfaces;i = j)
5302                 {
5303                         surface = texturesurfacelist[i];
5304                         j = i + 1;
5305                         if (surface->num_triangles > MAXBATCHTRIANGLES)
5306                         {
5307                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5308                                 continue;
5309                         }
5310                         memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
5311                         batchtriangles = surface->num_triangles;
5312                         firstvertex = surface->num_firstvertex;
5313                         endvertex = surface->num_firstvertex + surface->num_vertices;
5314                         for (;j < texturenumsurfaces;j++)
5315                         {
5316                                 surface2 = texturesurfacelist[j];
5317                                 if (batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
5318                                         break;
5319                                 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
5320                                 batchtriangles += surface2->num_triangles;
5321                                 firstvertex = min(firstvertex, surface2->num_firstvertex);
5322                                 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
5323                         }
5324                         surface2 = texturesurfacelist[j-1];
5325                         numvertices = endvertex - firstvertex;
5326                         R_Mesh_Draw(firstvertex, numvertices, batchtriangles, batchelements, 0, 0);
5327                 }
5328         }
5329         else if (r_batchmode.integer == 1)
5330         {
5331                 for (i = 0;i < texturenumsurfaces;i = j)
5332                 {
5333                         surface = texturesurfacelist[i];
5334                         for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
5335                                 if (texturesurfacelist[j] != surface2)
5336                                         break;
5337                         surface2 = texturesurfacelist[j-1];
5338                         numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
5339                         numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
5340                         GL_LockArrays(surface->num_firstvertex, numvertices);
5341                         R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5342                 }
5343         }
5344         else
5345         {
5346                 for (i = 0;i < texturenumsurfaces;i++)
5347                 {
5348                         surface = texturesurfacelist[i];
5349                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5350                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5351                 }
5352         }
5353 }
5354
5355 static void RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(int texturenumsurfaces, msurface_t **texturesurfacelist, int lightmaptexunit, int deluxemaptexunit, int refractiontexunit, int reflectiontexunit)
5356 {
5357         int i, planeindex, vertexindex;
5358         float d, bestd;
5359         vec3_t vert;
5360         const float *v;
5361         r_waterstate_waterplane_t *p, *bestp;
5362         msurface_t *surface;
5363         if (r_waterstate.renderingscene)
5364                 return;
5365         for (i = 0;i < texturenumsurfaces;i++)
5366         {
5367                 surface = texturesurfacelist[i];
5368                 if (lightmaptexunit >= 0)
5369                         R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5370                 if (deluxemaptexunit >= 0)
5371                         R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5372                 // pick the closest matching water plane
5373                 bestd = 0;
5374                 bestp = NULL;
5375                 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
5376                 {
5377                         d = 0;
5378                         for (vertexindex = 0, v = rsurface.modelvertex3f + surface->num_firstvertex * 3;vertexindex < surface->num_vertices;vertexindex++, v += 3)
5379                         {
5380                                 Matrix4x4_Transform(&rsurface.matrix, v, vert);
5381                                 d += fabs(PlaneDiff(vert, &p->plane));
5382                         }
5383                         if (bestd > d || !bestp)
5384                         {
5385                                 bestd = d;
5386                                 bestp = p;
5387                         }
5388                 }
5389                 if (bestp)
5390                 {
5391                         if (refractiontexunit >= 0)
5392                                 R_Mesh_TexBind(refractiontexunit, R_GetTexture(bestp->texture_refraction));
5393                         if (reflectiontexunit >= 0)
5394                                 R_Mesh_TexBind(reflectiontexunit, R_GetTexture(bestp->texture_reflection));
5395                 }
5396                 else
5397                 {
5398                         if (refractiontexunit >= 0)
5399                                 R_Mesh_TexBind(refractiontexunit, R_GetTexture(r_texture_black));
5400                         if (reflectiontexunit >= 0)
5401                                 R_Mesh_TexBind(reflectiontexunit, R_GetTexture(r_texture_black));
5402                 }
5403                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5404                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5405         }
5406 }
5407
5408 static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurface_t **texturesurfacelist, int lightmaptexunit, int deluxemaptexunit)
5409 {
5410         int i;
5411         int j;
5412         const msurface_t *surface = texturesurfacelist[0];
5413         const msurface_t *surface2;
5414         int firstvertex;
5415         int endvertex;
5416         int numvertices;
5417         int numtriangles;
5418         // TODO: lock all array ranges before render, rather than on each surface
5419         if (texturenumsurfaces == 1)
5420         {
5421                 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5422                 if (deluxemaptexunit >= 0)
5423                         R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5424                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5425                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5426         }
5427         else if (r_batchmode.integer == 2)
5428         {
5429                 #define MAXBATCHTRIANGLES 4096
5430                 int batchtriangles = 0;
5431                 int batchelements[MAXBATCHTRIANGLES*3];
5432                 for (i = 0;i < texturenumsurfaces;i = j)
5433                 {
5434                         surface = texturesurfacelist[i];
5435                         R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5436                         if (deluxemaptexunit >= 0)
5437                                 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5438                         j = i + 1;
5439                         if (surface->num_triangles > MAXBATCHTRIANGLES)
5440                         {
5441                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5442                                 continue;
5443                         }
5444                         memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
5445                         batchtriangles = surface->num_triangles;
5446                         firstvertex = surface->num_firstvertex;
5447                         endvertex = surface->num_firstvertex + surface->num_vertices;
5448                         for (;j < texturenumsurfaces;j++)
5449                         {
5450                                 surface2 = texturesurfacelist[j];
5451                                 if (surface2->lightmaptexture != surface->lightmaptexture || batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
5452                                         break;
5453                                 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
5454                                 batchtriangles += surface2->num_triangles;
5455                                 firstvertex = min(firstvertex, surface2->num_firstvertex);
5456                                 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
5457                         }
5458                         surface2 = texturesurfacelist[j-1];
5459                         numvertices = endvertex - firstvertex;
5460                         R_Mesh_Draw(firstvertex, numvertices, batchtriangles, batchelements, 0, 0);
5461                 }
5462         }
5463         else if (r_batchmode.integer == 1)
5464         {
5465 #if 0
5466                 Con_Printf("%s batch sizes ignoring lightmap:", rsurface.texture->name);
5467                 for (i = 0;i < texturenumsurfaces;i = j)
5468                 {
5469                         surface = texturesurfacelist[i];
5470                         for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
5471                                 if (texturesurfacelist[j] != surface2)
5472                                         break;
5473                         Con_Printf(" %i", j - i);
5474                 }
5475                 Con_Printf("\n");
5476                 Con_Printf("%s batch sizes honoring lightmap:", rsurface.texture->name);
5477 #endif
5478                 for (i = 0;i < texturenumsurfaces;i = j)
5479                 {
5480                         surface = texturesurfacelist[i];
5481                         R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5482                         if (deluxemaptexunit >= 0)
5483                                 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5484                         for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
5485                                 if (texturesurfacelist[j] != surface2 || texturesurfacelist[j]->lightmaptexture != surface->lightmaptexture)
5486                                         break;
5487 #if 0
5488                         Con_Printf(" %i", j - i);
5489 #endif
5490                         surface2 = texturesurfacelist[j-1];
5491                         numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
5492                         numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
5493                         GL_LockArrays(surface->num_firstvertex, numvertices);
5494                         R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5495                 }
5496 #if 0
5497                 Con_Printf("\n");
5498 #endif
5499         }
5500         else
5501         {
5502                 for (i = 0;i < texturenumsurfaces;i++)
5503                 {
5504                         surface = texturesurfacelist[i];
5505                         R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5506                         if (deluxemaptexunit >= 0)
5507                                 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5508                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5509                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5510                 }
5511         }
5512 }
5513
5514 static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
5515 {
5516         int j;
5517         int texturesurfaceindex;
5518         if (r_showsurfaces.integer == 2)
5519         {
5520                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5521                 {
5522                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5523                         for (j = 0;j < surface->num_triangles;j++)
5524                         {
5525                                 float f = ((j + surface->num_firsttriangle) & 31) * (1.0f / 31.0f) * r_refdef.view.colorscale;
5526                                 GL_Color(f, f, f, 1);
5527                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, 1, (rsurface.modelelement3i + 3 * (j + surface->num_firsttriangle)), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * (j + surface->num_firsttriangle)));
5528                         }
5529                 }
5530         }
5531         else
5532         {
5533                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5534                 {
5535                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5536                         int k = (int)(((size_t)surface) / sizeof(msurface_t));
5537                         GL_Color((k & 15) * (1.0f / 16.0f) * r_refdef.view.colorscale, ((k >> 4) & 15) * (1.0f / 16.0f) * r_refdef.view.colorscale, ((k >> 8) & 15) * (1.0f / 16.0f) * r_refdef.view.colorscale, 1);
5538                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5539                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5540                 }
5541         }
5542 }
5543
5544 static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, msurface_t **texturesurfacelist)
5545 {
5546         int texturesurfaceindex;
5547         int i;
5548         float f;
5549         float *v, *c, *c2;
5550         if (rsurface.lightmapcolor4f)
5551         {
5552                 // generate color arrays for the surfaces in this list
5553                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5554                 {
5555                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5556                         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)
5557                         {
5558                                 f = FogPoint_Model(v);
5559                                 c2[0] = c[0] * f;
5560                                 c2[1] = c[1] * f;
5561                                 c2[2] = c[2] * f;
5562                                 c2[3] = c[3];
5563                         }
5564                 }
5565         }
5566         else
5567         {
5568                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5569                 {
5570                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5571                         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)
5572                         {
5573                                 f = FogPoint_Model(v);
5574                                 c2[0] = f;
5575                                 c2[1] = f;
5576                                 c2[2] = f;
5577                                 c2[3] = 1;
5578                         }
5579                 }
5580         }
5581         rsurface.lightmapcolor4f = rsurface.array_color4f;
5582         rsurface.lightmapcolor4f_bufferobject = 0;
5583         rsurface.lightmapcolor4f_bufferoffset = 0;
5584 }
5585
5586 static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a)
5587 {
5588         int texturesurfaceindex;
5589         int i;
5590         float *c, *c2;
5591         if (!rsurface.lightmapcolor4f)
5592                 return;
5593         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5594         {
5595                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5596                 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)
5597                 {
5598                         c2[0] = c[0] * r;
5599                         c2[1] = c[1] * g;
5600                         c2[2] = c[2] * b;
5601                         c2[3] = c[3] * a;
5602                 }
5603         }
5604         rsurface.lightmapcolor4f = rsurface.array_color4f;
5605         rsurface.lightmapcolor4f_bufferobject = 0;
5606         rsurface.lightmapcolor4f_bufferoffset = 0;
5607 }
5608
5609 static void RSurf_DrawBatch_GL11_Lightmap(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5610 {
5611         // TODO: optimize
5612         rsurface.lightmapcolor4f = NULL;
5613         rsurface.lightmapcolor4f_bufferobject = 0;
5614         rsurface.lightmapcolor4f_bufferoffset = 0;
5615         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5616         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5617         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5618         GL_Color(r, g, b, a);
5619         RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 0, -1);
5620 }
5621
5622 static void RSurf_DrawBatch_GL11_Unlit(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5623 {
5624         // TODO: optimize applyfog && applycolor case
5625         // just apply fog if necessary, and tint the fog color array if necessary
5626         rsurface.lightmapcolor4f = NULL;
5627         rsurface.lightmapcolor4f_bufferobject = 0;
5628         rsurface.lightmapcolor4f_bufferoffset = 0;
5629         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5630         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5631         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5632         GL_Color(r, g, b, a);
5633         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5634 }
5635
5636 static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5637 {
5638         int texturesurfaceindex;
5639         int i;
5640         float *c;
5641         // TODO: optimize
5642         if (texturesurfacelist[0]->lightmapinfo && texturesurfacelist[0]->lightmapinfo->stainsamples)
5643         {
5644                 // generate color arrays for the surfaces in this list
5645                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5646                 {
5647                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5648                         for (i = 0, c = rsurface.array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
5649                         {
5650                                 if (surface->lightmapinfo->samples)
5651                                 {
5652                                         const unsigned char *lm = surface->lightmapinfo->samples + (rsurface.modellightmapoffsets + surface->num_firstvertex)[i];
5653                                         float scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
5654                                         VectorScale(lm, scale, c);
5655                                         if (surface->lightmapinfo->styles[1] != 255)
5656                                         {
5657                                                 int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
5658                                                 lm += size3;
5659                                                 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
5660                                                 VectorMA(c, scale, lm, c);
5661                                                 if (surface->lightmapinfo->styles[2] != 255)
5662                                                 {
5663                                                         lm += size3;
5664                                                         scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
5665                                                         VectorMA(c, scale, lm, c);
5666                                                         if (surface->lightmapinfo->styles[3] != 255)
5667                                                         {
5668                                                                 lm += size3;
5669                                                                 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
5670                                                                 VectorMA(c, scale, lm, c);
5671                                                         }
5672                                                 }
5673                                         }
5674                                 }
5675                                 else
5676                                         VectorClear(c);
5677                                 c[3] = 1;
5678                         }
5679                 }
5680                 rsurface.lightmapcolor4f = rsurface.array_color4f;
5681                 rsurface.lightmapcolor4f_bufferobject = 0;
5682                 rsurface.lightmapcolor4f_bufferoffset = 0;
5683         }
5684         else
5685         {
5686                 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
5687                 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
5688                 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
5689         }
5690         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5691         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5692         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5693         GL_Color(r, g, b, a);
5694         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5695 }
5696
5697 static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5698 {
5699         int texturesurfaceindex;
5700         int i;
5701         float f;
5702         float *v, *c, *c2;
5703         vec3_t ambientcolor;
5704         vec3_t diffusecolor;
5705         vec3_t lightdir;
5706         // TODO: optimize
5707         // model lighting
5708         VectorCopy(rsurface.modellight_lightdir, lightdir);
5709         f = 0.5f * r_refdef.lightmapintensity;
5710         ambientcolor[0] = rsurface.modellight_ambient[0] * r * f;
5711         ambientcolor[1] = rsurface.modellight_ambient[1] * g * f;
5712         ambientcolor[2] = rsurface.modellight_ambient[2] * b * f;
5713         diffusecolor[0] = rsurface.modellight_diffuse[0] * r * f;
5714         diffusecolor[1] = rsurface.modellight_diffuse[1] * g * f;
5715         diffusecolor[2] = rsurface.modellight_diffuse[2] * b * f;
5716         if (VectorLength2(diffusecolor) > 0)
5717         {
5718                 // generate color arrays for the surfaces in this list
5719                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5720                 {
5721                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5722                         int numverts = surface->num_vertices;
5723                         v = rsurface.vertex3f + 3 * surface->num_firstvertex;
5724                         c2 = rsurface.normal3f + 3 * surface->num_firstvertex;
5725                         c = rsurface.array_color4f + 4 * surface->num_firstvertex;
5726                         // q3-style directional shading
5727                         for (i = 0;i < numverts;i++, v += 3, c2 += 3, c += 4)
5728                         {
5729                                 if ((f = DotProduct(c2, lightdir)) > 0)
5730                                         VectorMA(ambientcolor, f, diffusecolor, c);
5731                                 else
5732                                         VectorCopy(ambientcolor, c);
5733                                 c[3] = a;
5734                         }
5735                 }
5736                 r = 1;
5737                 g = 1;
5738                 b = 1;
5739                 a = 1;
5740                 applycolor = false;
5741                 rsurface.lightmapcolor4f = rsurface.array_color4f;
5742                 rsurface.lightmapcolor4f_bufferobject = 0;
5743                 rsurface.lightmapcolor4f_bufferoffset = 0;
5744         }
5745         else
5746         {
5747                 r = ambientcolor[0];
5748                 g = ambientcolor[1];
5749                 b = ambientcolor[2];
5750                 rsurface.lightmapcolor4f = NULL;
5751                 rsurface.lightmapcolor4f_bufferobject = 0;
5752                 rsurface.lightmapcolor4f_bufferoffset = 0;
5753         }
5754         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5755         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5756         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5757         GL_Color(r, g, b, a);
5758         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5759 }
5760
5761 void RSurf_SetupDepthAndCulling(void)
5762 {
5763         // submodels are biased to avoid z-fighting with world surfaces that they
5764         // may be exactly overlapping (avoids z-fighting artifacts on certain
5765         // doors and things in Quake maps)
5766         GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5767         GL_PolygonOffset(rsurface.basepolygonfactor + rsurface.texture->biaspolygonfactor, rsurface.basepolygonoffset + rsurface.texture->biaspolygonoffset);
5768         GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
5769         GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_refdef.view.cullface_back);
5770 }
5771
5772 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, msurface_t **texturesurfacelist)
5773 {
5774         // transparent sky would be ridiculous
5775         if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
5776                 return;
5777         R_SetupGenericShader(false);
5778         if (skyrendernow)
5779         {
5780                 skyrendernow = false;
5781                 // we have to force off the water clipping plane while rendering sky
5782                 R_SetupView(false);
5783                 R_Sky();
5784                 R_SetupView(true);
5785                 // restore entity matrix
5786                 R_Mesh_Matrix(&rsurface.matrix);
5787         }
5788         RSurf_SetupDepthAndCulling();
5789         GL_DepthMask(true);
5790         // LordHavoc: HalfLife maps have freaky skypolys so don't use
5791         // skymasking on them, and Quake3 never did sky masking (unlike
5792         // software Quake and software Quake2), so disable the sky masking
5793         // in Quake3 maps as it causes problems with q3map2 sky tricks,
5794         // and skymasking also looks very bad when noclipping outside the
5795         // level, so don't use it then either.
5796         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_refdef.viewcache.world_novis)
5797         {
5798                 GL_Color(r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], 1);
5799                 R_Mesh_ColorPointer(NULL, 0, 0);
5800                 R_Mesh_ResetTextureState();
5801                 if (skyrendermasked)
5802                 {
5803                         R_SetupDepthOrShadowShader();
5804                         // depth-only (masking)
5805                         GL_ColorMask(0,0,0,0);
5806                         // just to make sure that braindead drivers don't draw
5807                         // anything despite that colormask...
5808                         GL_BlendFunc(GL_ZERO, GL_ONE);
5809                 }
5810                 else
5811                 {
5812                         R_SetupGenericShader(false);
5813                         // fog sky
5814                         GL_BlendFunc(GL_ONE, GL_ZERO);
5815                 }
5816                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5817                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5818                 if (skyrendermasked)
5819                         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5820         }
5821         R_Mesh_ResetTextureState();
5822         GL_Color(1, 1, 1, 1);
5823 }
5824
5825 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, msurface_t **texturesurfacelist, qboolean writedepth)
5826 {
5827         if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION)))
5828                 return;
5829
5830         R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
5831         R_Mesh_TexBind(GL20TU_NORMAL, R_GetTexture(rsurface.texture->currentskinframe->nmap));
5832         R_Mesh_TexBind(GL20TU_COLOR, R_GetTexture(rsurface.texture->basetexture));
5833         R_Mesh_TexBind(GL20TU_GLOSS, R_GetTexture(rsurface.texture->glosstexture));
5834         R_Mesh_TexBind(GL20TU_GLOW, R_GetTexture(rsurface.texture->currentskinframe->glow));
5835         if (rsurface.texture->backgroundcurrentskinframe)
5836         {
5837                 R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL, R_GetTexture(rsurface.texture->backgroundcurrentskinframe->nmap));
5838                 R_Mesh_TexBind(GL20TU_SECONDARY_COLOR, R_GetTexture(rsurface.texture->backgroundbasetexture));
5839                 R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS, R_GetTexture(rsurface.texture->backgroundglosstexture));
5840                 R_Mesh_TexBind(GL20TU_SECONDARY_GLOW, R_GetTexture(rsurface.texture->backgroundcurrentskinframe->glow));
5841         }
5842         R_Mesh_TexBind(GL20TU_PANTS, R_GetTexture(rsurface.texture->currentskinframe->pants));
5843         R_Mesh_TexBind(GL20TU_SHIRT, R_GetTexture(rsurface.texture->currentskinframe->shirt));
5844         R_Mesh_TexBind(GL20TU_FOGMASK, R_GetTexture(r_texture_fogattenuation));
5845         if ((rsurface.uselightmaptexture || (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND))
5846                 R_Mesh_ColorPointer(NULL, 0, 0);
5847         else
5848                 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5849
5850         if (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
5851         {
5852                 // render background
5853                 GL_BlendFunc(GL_ONE, GL_ZERO);
5854                 GL_DepthMask(true);
5855                 GL_AlphaTest(false);
5856
5857                 GL_Color(1, 1, 1, 1);
5858                 R_Mesh_ColorPointer(NULL, 0, 0);
5859
5860                 R_SetupSurfaceShader(vec3_origin, rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND);
5861                 if (r_glsl_permutation)
5862                 {
5863                         RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
5864                         R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
5865                         R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
5866                         R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
5867                         R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
5868                         R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
5869                         RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, -1, -1, r_glsl_permutation->loc_Texture_Refraction >= 0 ? GL20TU_REFRACTION : -1, r_glsl_permutation->loc_Texture_Reflection >= 0 ? GL20TU_REFLECTION : -1);
5870                 }
5871                 GL_LockArrays(0, 0);
5872
5873                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5874                 GL_DepthMask(false);
5875                 if ((rsurface.uselightmaptexture || (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND))
5876                         R_Mesh_ColorPointer(NULL, 0, 0);
5877                 else
5878                         R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5879                 R_Mesh_TexBind(GL20TU_REFRACTION, R_GetTexture(r_texture_white)); // changed per surface
5880                 R_Mesh_TexBind(GL20TU_REFLECTION, R_GetTexture(r_texture_white)); // changed per surface
5881         }
5882
5883         R_SetupSurfaceShader(vec3_origin, rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE);
5884         if (!r_glsl_permutation)
5885                 return;
5886
5887         RSurf_PrepareVerticesForBatch(r_glsl_permutation->loc_Texture_Normal >= 0 || r_glsl_permutation->loc_LightDir >= 0, r_glsl_permutation->loc_Texture_Normal >= 0, texturenumsurfaces, texturesurfacelist);
5888         R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
5889         R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
5890         R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
5891         R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
5892         R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
5893
5894         if (r_glsl_permutation->loc_Texture_Refraction >= 0)
5895         {
5896                 GL_BlendFunc(GL_ONE, GL_ZERO);
5897                 GL_DepthMask(true);
5898                 GL_AlphaTest(false);
5899         }
5900         else
5901         {
5902                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5903                 GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
5904                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5905         }
5906
5907         if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
5908         {
5909                 if (r_glsl_permutation->loc_Texture_Refraction >= 0 || r_glsl_permutation->loc_Texture_Reflection >= 0)
5910                         RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, GL20TU_LIGHTMAP, r_glsl_permutation->loc_Texture_Deluxemap >= 0 ? GL20TU_DELUXEMAP : -1, r_glsl_permutation->loc_Texture_Refraction >= 0 ? GL20TU_REFRACTION : -1, r_glsl_permutation->loc_Texture_Reflection >= 0 ? GL20TU_REFLECTION : -1);
5911                 else
5912                         RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, GL20TU_LIGHTMAP, r_glsl_permutation->loc_Texture_Deluxemap >= 0 ? GL20TU_DELUXEMAP : -1);
5913         }
5914         else
5915         {
5916                 if (r_glsl_permutation->loc_Texture_Refraction >= 0 || r_glsl_permutation->loc_Texture_Reflection >= 0)
5917                         RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, -1, -1, r_glsl_permutation->loc_Texture_Refraction >= 0 ? GL20TU_REFRACTION : -1, r_glsl_permutation->loc_Texture_Reflection >= 0 ? GL20TU_REFLECTION : -1);
5918                 else
5919                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5920         }
5921         GL_LockArrays(0, 0);
5922 }
5923
5924 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **texturesurfacelist, qboolean writedepth)
5925 {
5926         // OpenGL 1.3 path - anything not completely ancient
5927         int texturesurfaceindex;
5928         qboolean applycolor;
5929         qboolean applyfog;
5930         rmeshstate_t m;
5931         int layerindex;
5932         const texturelayer_t *layer;
5933         RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
5934
5935         for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
5936         {
5937                 vec4_t layercolor;
5938                 int layertexrgbscale;
5939                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5940                 {
5941                         if (layerindex == 0)
5942                                 GL_AlphaTest(true);
5943                         else
5944                         {
5945                                 GL_AlphaTest(false);
5946                                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
5947                         }
5948                 }
5949                 GL_DepthMask(layer->depthmask && writedepth);
5950                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
5951                 if (layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2)
5952                 {
5953                         layertexrgbscale = 4;
5954                         VectorScale(layer->color, 0.25f, layercolor);
5955                 }
5956                 else if (layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1)
5957                 {
5958                         layertexrgbscale = 2;
5959                         VectorScale(layer->color, 0.5f, layercolor);
5960                 }
5961                 else
5962                 {
5963                         layertexrgbscale = 1;
5964                         VectorScale(layer->color, 1.0f, layercolor);
5965                 }
5966                 layercolor[3] = layer->color[3];
5967                 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
5968                 R_Mesh_ColorPointer(NULL, 0, 0);
5969                 applyfog = (layer->flags & TEXTURELAYERFLAG_FOGDARKEN) != 0;
5970                 switch (layer->type)
5971                 {
5972                 case TEXTURELAYERTYPE_LITTEXTURE:
5973                         memset(&m, 0, sizeof(m));
5974                         m.tex[0] = R_GetTexture(r_texture_white);
5975                         m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
5976                         m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
5977                         m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
5978                         m.tex[1] = R_GetTexture(layer->texture);
5979                         m.texmatrix[1] = layer->texmatrix;
5980                         m.texrgbscale[1] = layertexrgbscale;
5981                         m.pointer_texcoord[1] = rsurface.texcoordtexture2f;
5982                         m.pointer_texcoord_bufferobject[1] = rsurface.texcoordtexture2f_bufferobject;
5983                         m.pointer_texcoord_bufferoffset[1] = rsurface.texcoordtexture2f_bufferoffset;
5984                         R_Mesh_TextureState(&m);
5985                         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5986                                 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5987                         else if (rsurface.uselightmaptexture)
5988                                 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5989                         else
5990                                 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5991                         break;
5992                 case TEXTURELAYERTYPE_TEXTURE:
5993                         memset(&m, 0, sizeof(m));
5994                         m.tex[0] = R_GetTexture(layer->texture);
5995                         m.texmatrix[0] = layer->texmatrix;
5996                         m.texrgbscale[0] = layertexrgbscale;
5997                         m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5998                         m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5999                         m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
6000                         R_Mesh_TextureState(&m);
6001                         RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
6002                         break;
6003                 case TEXTURELAYERTYPE_FOG:
6004                         memset(&m, 0, sizeof(m));
6005                         m.texrgbscale[0] = layertexrgbscale;
6006                         if (layer->texture)
6007                         {
6008                                 m.tex[0] = R_GetTexture(layer->texture);
6009                                 m.texmatrix[0] = layer->texmatrix;
6010                                 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
6011                                 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
6012                                 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
6013                         }
6014                         R_Mesh_TextureState(&m);
6015                         // generate a color array for the fog pass
6016                         R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
6017                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
6018                         {
6019                                 int i;
6020                                 float f, *v, *c;
6021                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
6022                                 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)
6023                                 {
6024                                         f = 1 - FogPoint_Model(v);
6025                                         c[0] = layercolor[0];
6026                                         c[1] = layercolor[1];
6027                                         c[2] = layercolor[2];
6028                                         c[3] = f * layercolor[3];
6029                                 }
6030                         }
6031                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
6032                         break;
6033                 default:
6034                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
6035                 }
6036                 GL_LockArrays(0, 0);
6037         }
6038         CHECKGLERROR
6039         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
6040         {
6041                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
6042                 GL_AlphaTest(false);
6043         }
6044 }
6045
6046 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **texturesurfacelist, qboolean writedepth)
6047 {
6048         // OpenGL 1.1 - crusty old voodoo path
6049         int texturesurfaceindex;
6050         qboolean applyfog;
6051         rmeshstate_t m;
6052         int layerindex;
6053         const texturelayer_t *layer;
6054         RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
6055
6056         for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
6057         {
6058                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
6059                 {
6060                         if (layerindex == 0)
6061                                 GL_AlphaTest(true);
6062                         else
6063                         {
6064                                 GL_AlphaTest(false);
6065                                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
6066                         }
6067                 }
6068                 GL_DepthMask(layer->depthmask && writedepth);
6069                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
6070                 R_Mesh_ColorPointer(NULL, 0, 0);
6071                 applyfog = (layer->flags & TEXTURELAYERFLAG_FOGDARKEN) != 0;
6072                 switch (layer->type)
6073                 {
6074                 case TEXTURELAYERTYPE_LITTEXTURE:
6075                         if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
6076                         {
6077                                 // two-pass lit texture with 2x rgbscale
6078                                 // first the lightmap pass
6079                                 memset(&m, 0, sizeof(m));
6080                                 m.tex[0] = R_GetTexture(r_texture_white);
6081                                 m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
6082                                 m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
6083                                 m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
6084                                 R_Mesh_TextureState(&m);
6085                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
6086                                         RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
6087                                 else if (rsurface.uselightmaptexture)
6088                                         RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
6089                                 else
6090                                         RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
6091                                 GL_LockArrays(0, 0);
6092                                 // then apply the texture to it
6093                                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
6094                                 memset(&m, 0, sizeof(m));
6095                                 m.tex[0] = R_GetTexture(layer->texture);
6096                                 m.texmatrix[0] = layer->texmatrix;
6097                                 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
6098                                 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
6099                                 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
6100                                 R_Mesh_TextureState(&m);
6101                                 RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layer->color[0] * 0.5f, layer->color[1] * 0.5f, layer->color[2] * 0.5f, layer->color[3], layer->color[0] != 2 || layer->color[1] != 2 || layer->color[2] != 2 || layer->color[3] != 1, false);
6102                         }
6103                         else
6104                         {
6105                                 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
6106                                 memset(&m, 0, sizeof(m));
6107                                 m.tex[0] = R_GetTexture(layer->texture);
6108                                 m.texmatrix[0] = layer->texmatrix;
6109                                 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
6110                                 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
6111                                 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
6112                                 R_Mesh_TextureState(&m);
6113                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
6114                                         RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
6115                                 else
6116                                         RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
6117                         }
6118                         break;
6119                 case TEXTURELAYERTYPE_TEXTURE:
6120                         // singletexture unlit texture with transparency support
6121                         memset(&m, 0, sizeof(m));
6122                         m.tex[0] = R_GetTexture(layer->texture);
6123                         m.texmatrix[0] = layer->texmatrix;
6124                         m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
6125                         m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
6126                         m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
6127                         R_Mesh_TextureState(&m);
6128                         RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
6129                         break;
6130                 case TEXTURELAYERTYPE_FOG:
6131                         // singletexture fogging
6132                         R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
6133                         if (layer->texture)
6134                         {
6135                                 memset(&m, 0, sizeof(m));
6136                                 m.tex[0] = R_GetTexture(layer->texture);
6137                                 m.texmatrix[0] = layer->texmatrix;
6138                                 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
6139                                 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
6140                                 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
6141                                 R_Mesh_TextureState(&m);
6142                         }
6143                         else
6144                                 R_Mesh_ResetTextureState();
6145                         // generate a color array for the fog pass
6146                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
6147                         {
6148                                 int i;
6149                                 float f, *v, *c;
6150                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
6151                                 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)
6152                                 {
6153                                         f = 1 - FogPoint_Model(v);
6154                                         c[0] = layer->color[0];
6155                                         c[1] = layer->color[1];
6156                                         c[2] = layer->color[2];
6157                                         c[3] = f * layer->color[3];
6158                                 }
6159                         }
6160                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
6161                         break;
6162                 default:
6163                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
6164                 }
6165                 GL_LockArrays(0, 0);
6166         }
6167         CHECKGLERROR
6168         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
6169         {
6170                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
6171                 GL_AlphaTest(false);
6172         }
6173 }
6174
6175 static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **texturesurfacelist, qboolean writedepth)
6176 {
6177         CHECKGLERROR
6178         RSurf_SetupDepthAndCulling();
6179         if (r_glsl.integer && gl_support_fragment_shader)
6180                 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth);
6181         else if (gl_combine.integer && r_textureunits.integer >= 2)
6182                 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
6183         else
6184                 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
6185         CHECKGLERROR
6186 }
6187
6188 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
6189 {
6190         int i, j;
6191         int texturenumsurfaces, endsurface;
6192         texture_t *texture;
6193         msurface_t *surface;
6194         msurface_t *texturesurfacelist[1024];
6195
6196         // if the model is static it doesn't matter what value we give for
6197         // wantnormals and wanttangents, so this logic uses only rules applicable
6198         // to a model, knowing that they are meaningless otherwise
6199         if (ent == r_refdef.scene.worldentity)
6200                 RSurf_ActiveWorldEntity();
6201         else if ((ent->effects & EF_FULLBRIGHT) || r_showsurfaces.integer || VectorLength2(ent->modellight_diffuse) < (1.0f / 256.0f))
6202                 RSurf_ActiveModelEntity(ent, false, false);
6203         else
6204                 RSurf_ActiveModelEntity(ent, true, r_glsl.integer && gl_support_fragment_shader);
6205
6206         for (i = 0;i < numsurfaces;i = j)
6207         {
6208                 j = i + 1;
6209                 surface = rsurface.modelsurfaces + surfacelist[i];
6210                 texture = surface->texture;
6211                 R_UpdateTextureInfo(ent, texture);
6212                 rsurface.texture = texture->currentframe;
6213                 rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
6214                 // scan ahead until we find a different texture
6215                 endsurface = min(i + 1024, numsurfaces);
6216                 texturenumsurfaces = 0;
6217                 texturesurfacelist[texturenumsurfaces++] = surface;
6218                 for (;j < endsurface;j++)
6219                 {
6220                         surface = rsurface.modelsurfaces + surfacelist[j];
6221                         if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
6222                                 break;
6223                         texturesurfacelist[texturenumsurfaces++] = surface;
6224                 }
6225                 // render the range of surfaces
6226                 R_DrawTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false);
6227         }
6228         GL_AlphaTest(false);
6229 }
6230
6231 static void R_ProcessTextureSurfaceList(int texturenumsurfaces, msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, const entity_render_t *queueentity)
6232 {
6233         CHECKGLERROR
6234         if (depthonly)
6235         {
6236                 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
6237                         return;
6238                 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
6239                         return;
6240                 RSurf_SetupDepthAndCulling();
6241                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
6242                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
6243         }
6244         else if (r_showsurfaces.integer)
6245         {
6246                 RSurf_SetupDepthAndCulling();
6247                 GL_DepthTest(true);
6248                 GL_BlendFunc(GL_ONE, GL_ZERO);
6249                 GL_DepthMask(true);
6250                 GL_AlphaTest(false);
6251                 R_Mesh_ColorPointer(NULL, 0, 0);
6252                 R_Mesh_ResetTextureState();
6253                 R_SetupGenericShader(false);
6254                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
6255                 if (!r_refdef.view.showdebug)
6256                 {
6257                         GL_Color(0, 0, 0, 1);
6258                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
6259                 }
6260                 else
6261                         RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
6262         }
6263         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
6264                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
6265         else if (!rsurface.texture->currentnumlayers)
6266                 return;
6267         else if ((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) && queueentity)
6268         {
6269                 // transparent surfaces get pushed off into the transparent queue
6270                 int surfacelistindex;
6271                 const msurface_t *surface;
6272                 vec3_t tempcenter, center;
6273                 for (surfacelistindex = 0;surfacelistindex < texturenumsurfaces;surfacelistindex++)
6274                 {
6275                         surface = texturesurfacelist[surfacelistindex];
6276                         tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
6277                         tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
6278                         tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
6279                         Matrix4x4_Transform(&rsurface.matrix, tempcenter, center);
6280                         R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_refdef.view.origin : center, R_DrawSurface_TransparentCallback, queueentity, surface - rsurface.modelsurfaces, rsurface.rtlight);
6281                 }
6282         }
6283         else
6284         {
6285                 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
6286                 R_DrawTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST));
6287         }
6288         CHECKGLERROR
6289 }
6290
6291 void R_QueueSurfaceList(entity_render_t *ent, int numsurfaces, msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes)
6292 {
6293         int i, j;
6294         texture_t *texture;
6295         // if we're rendering water textures (extra scene renders), use a separate loop to avoid burdening the main one
6296         if (addwaterplanes)
6297         {
6298                 for (i = 0;i < numsurfaces;i++)
6299                         if (surfacelist[i]->texture->currentframe->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION))
6300                                 R_Water_AddWaterPlane(surfacelist[i]);
6301                 return;
6302         }
6303         // break the surface list down into batches by texture and use of lightmapping
6304         for (i = 0;i < numsurfaces;i = j)
6305         {
6306                 j = i + 1;
6307                 // texture is the base texture pointer, rsurface.texture is the
6308                 // current frame/skin the texture is directing us to use (for example
6309                 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
6310                 // use skin 1 instead)
6311                 texture = surfacelist[i]->texture;
6312                 rsurface.texture = texture->currentframe;
6313                 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL;
6314                 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
6315                 {
6316                         // if this texture is not the kind we want, skip ahead to the next one
6317                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
6318                                 ;
6319                         continue;
6320                 }
6321                 // simply scan ahead until we find a different texture or lightmap state
6322                 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
6323                         ;
6324                 // render the range of surfaces
6325                 R_ProcessTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, ent);
6326         }
6327 }
6328
6329 float locboxvertex3f[6*4*3] =
6330 {
6331         1,0,1, 1,0,0, 1,1,0, 1,1,1,
6332         0,1,1, 0,1,0, 0,0,0, 0,0,1,
6333         1,1,1, 1,1,0, 0,1,0, 0,1,1,
6334         0,0,1, 0,0,0, 1,0,0, 1,0,1,
6335         0,0,1, 1,0,1, 1,1,1, 0,1,1,
6336         1,0,0, 0,0,0, 0,1,0, 1,1,0
6337 };
6338
6339 int locboxelement3i[6*2*3] =
6340 {
6341          0, 1, 2, 0, 2, 3,
6342          4, 5, 6, 4, 6, 7,
6343          8, 9,10, 8,10,11,
6344         12,13,14, 12,14,15,
6345         16,17,18, 16,18,19,
6346         20,21,22, 20,22,23
6347 };
6348
6349 void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
6350 {
6351         int i, j;
6352         cl_locnode_t *loc = (cl_locnode_t *)ent;
6353         vec3_t mins, size;
6354         float vertex3f[6*4*3];
6355         CHECKGLERROR
6356         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6357         GL_DepthMask(false);
6358         GL_DepthRange(0, 1);
6359         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
6360         GL_DepthTest(true);
6361         GL_CullFace(GL_NONE);
6362         R_Mesh_Matrix(&identitymatrix);
6363
6364         R_Mesh_VertexPointer(vertex3f, 0, 0);
6365         R_Mesh_ColorPointer(NULL, 0, 0);
6366         R_Mesh_ResetTextureState();
6367         R_SetupGenericShader(false);
6368
6369         i = surfacelist[0];
6370         GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_refdef.view.colorscale,
6371                          ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_refdef.view.colorscale,
6372                          ((i & 0x01C0) >> 6) * (1.0f / 7.0f) * r_refdef.view.colorscale,
6373                         surfacelist[0] < 0 ? 0.5f : 0.125f);
6374
6375         if (VectorCompare(loc->mins, loc->maxs))
6376         {
6377                 VectorSet(size, 2, 2, 2);
6378                 VectorMA(loc->mins, -0.5f, size, mins);
6379         }
6380         else
6381         {
6382                 VectorCopy(loc->mins, mins);
6383                 VectorSubtract(loc->maxs, loc->mins, size);
6384         }
6385
6386         for (i = 0;i < 6*4*3;)
6387                 for (j = 0;j < 3;j++, i++)
6388                         vertex3f[i] = mins[j] + size[j] * locboxvertex3f[i];
6389
6390         R_Mesh_Draw(0, 6*4, 6*2, locboxelement3i, 0, 0);
6391 }
6392
6393 void R_DrawLocs(void)
6394 {
6395         int index;
6396         cl_locnode_t *loc, *nearestloc;
6397         vec3_t center;
6398         nearestloc = CL_Locs_FindNearest(cl.movement_origin);
6399         for (loc = cl.locnodes, index = 0;loc;loc = loc->next, index++)
6400         {
6401                 VectorLerp(loc->mins, 0.5f, loc->maxs, center);
6402                 R_MeshQueue_AddTransparent(center, R_DrawLoc_Callback, (entity_render_t *)loc, loc == nearestloc ? -1 : index, NULL);
6403         }
6404 }
6405
6406 void R_DrawDebugModel(entity_render_t *ent)
6407 {
6408         int i, j, k, l, flagsmask;
6409         const int *elements;
6410         q3mbrush_t *brush;
6411         msurface_t *surface;
6412         model_t *model = ent->model;
6413         vec3_t v;
6414
6415         flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WATER | MATERIALFLAG_WALL;
6416
6417         R_Mesh_ColorPointer(NULL, 0, 0);
6418         R_Mesh_ResetTextureState();
6419         R_SetupGenericShader(false);
6420         GL_DepthRange(0, 1);
6421         GL_DepthTest(!r_showdisabledepthtest.integer);
6422         GL_DepthMask(false);
6423         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6424
6425         if (r_showcollisionbrushes.value > 0 && model->brush.num_brushes)
6426         {
6427                 GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
6428                 for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
6429                 {
6430                         if (brush->colbrushf && brush->colbrushf->numtriangles)
6431                         {
6432                                 R_Mesh_VertexPointer(brush->colbrushf->points->v, 0, 0);
6433                                 GL_Color((i & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((i >> 5) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((i >> 10) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, r_showcollisionbrushes.value);
6434                                 R_Mesh_Draw(0, brush->colbrushf->numpoints, brush->colbrushf->numtriangles, brush->colbrushf->elements, 0, 0);
6435                         }
6436                 }
6437                 for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
6438                 {
6439                         if (surface->num_collisiontriangles)
6440                         {
6441                                 R_Mesh_VertexPointer(surface->data_collisionvertex3f, 0, 0);
6442                                 GL_Color((i & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((i >> 5) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((i >> 10) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, r_showcollisionbrushes.value);
6443                                 R_Mesh_Draw(0, surface->num_collisionvertices, surface->num_collisiontriangles, surface->data_collisionelement3i, 0, 0);
6444                         }
6445                 }
6446         }
6447
6448         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
6449
6450         if (r_showtris.integer || r_shownormals.integer)
6451         {
6452                 if (r_showdisabledepthtest.integer)
6453                 {
6454                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6455                         GL_DepthMask(false);
6456                 }
6457                 else
6458                 {
6459                         GL_BlendFunc(GL_ONE, GL_ZERO);
6460                         GL_DepthMask(true);
6461                 }
6462                 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
6463                 {
6464                         if (ent == r_refdef.scene.worldentity && !r_refdef.viewcache.world_surfacevisible[j])
6465                                 continue;
6466                         rsurface.texture = surface->texture->currentframe;
6467                         if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
6468                         {
6469                                 RSurf_PrepareVerticesForBatch(true, true, 1, &surface);
6470                                 if (r_showtris.value > 0)
6471                                 {
6472                                         if (!rsurface.texture->currentlayers->depthmask)
6473                                                 GL_Color(r_refdef.view.colorscale, 0, 0, r_showtris.value);
6474                                         else if (ent == r_refdef.scene.worldentity)
6475                                                 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, r_showtris.value);
6476                                         else
6477                                                 GL_Color(0, r_refdef.view.colorscale, 0, r_showtris.value);
6478                                         elements = (ent->model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);
6479                                         CHECKGLERROR
6480                                         qglBegin(GL_LINES);
6481                                         for (k = 0;k < surface->num_triangles;k++, elements += 3)
6482                                         {
6483 #define GLVERTEXELEMENT(n) qglVertex3f(rsurface.vertex3f[elements[n]*3+0], rsurface.vertex3f[elements[n]*3+1], rsurface.vertex3f[elements[n]*3+2])
6484                                                 GLVERTEXELEMENT(0);GLVERTEXELEMENT(1);
6485                                                 GLVERTEXELEMENT(1);GLVERTEXELEMENT(2);
6486                                                 GLVERTEXELEMENT(2);GLVERTEXELEMENT(0);
6487                                         }
6488                                         qglEnd();
6489                                         CHECKGLERROR
6490                                 }
6491                                 if (r_shownormals.value > 0)
6492                                 {
6493                                         qglBegin(GL_LINES);
6494                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
6495                                         {
6496                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
6497                                                 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
6498                                                 qglVertex3f(v[0], v[1], v[2]);
6499                                                 VectorMA(v, r_shownormals.value, rsurface.svector3f + l * 3, v);
6500                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
6501                                                 qglVertex3f(v[0], v[1], v[2]);
6502                                         }
6503                                         qglEnd();
6504                                         CHECKGLERROR
6505                                         qglBegin(GL_LINES);
6506                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
6507                                         {
6508                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
6509                                                 GL_Color(0, r_refdef.view.colorscale, 0, 1);
6510                                                 qglVertex3f(v[0], v[1], v[2]);
6511                                                 VectorMA(v, r_shownormals.value, rsurface.tvector3f + l * 3, v);
6512                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
6513                                                 qglVertex3f(v[0], v[1], v[2]);
6514                                         }
6515                                         qglEnd();
6516                                         CHECKGLERROR
6517                                         qglBegin(GL_LINES);
6518                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
6519                                         {
6520                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
6521                                                 GL_Color(0, 0, r_refdef.view.colorscale, 1);
6522                                                 qglVertex3f(v[0], v[1], v[2]);
6523                                                 VectorMA(v, r_shownormals.value, rsurface.normal3f + l * 3, v);
6524                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
6525                                                 qglVertex3f(v[0], v[1], v[2]);
6526                                         }
6527                                         qglEnd();
6528                                         CHECKGLERROR
6529                                 }
6530                         }
6531                 }
6532                 rsurface.texture = NULL;
6533         }
6534 }
6535
6536 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
6537 void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes, qboolean debug)
6538 {
6539         int i, j, endj, f, flagsmask;
6540         msurface_t *surface;
6541         texture_t *t;
6542         model_t *model = r_refdef.scene.worldmodel;
6543         const int maxsurfacelist = 1024;
6544         int numsurfacelist = 0;
6545         msurface_t *surfacelist[1024];
6546         if (model == NULL)
6547                 return;
6548
6549         RSurf_ActiveWorldEntity();
6550
6551         // update light styles on this submodel
6552         if (!skysurfaces && !depthonly && !addwaterplanes && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
6553         {
6554                 model_brush_lightstyleinfo_t *style;
6555                 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
6556                 {
6557                         if (style->value != r_refdef.scene.lightstylevalue[style->style])
6558                         {
6559                                 msurface_t *surfaces = model->data_surfaces;
6560                                 int *list = style->surfacelist;
6561                                 style->value = r_refdef.scene.lightstylevalue[style->style];
6562                                 for (j = 0;j < style->numsurfaces;j++)
6563                                         surfaces[list[j]].cached_dlight = true;
6564                         }
6565                 }
6566         }
6567
6568         R_UpdateAllTextureInfo(r_refdef.scene.worldentity);
6569         flagsmask = addwaterplanes ? (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) : (skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL));
6570
6571         if (debug)
6572         {
6573                 R_DrawDebugModel(r_refdef.scene.worldentity);
6574                 return;
6575         }
6576
6577         f = 0;
6578         t = NULL;
6579         rsurface.uselightmaptexture = false;
6580         rsurface.texture = NULL;
6581         rsurface.rtlight = NULL;
6582         numsurfacelist = 0;
6583         j = model->firstmodelsurface;
6584         endj = j + model->nummodelsurfaces;
6585         while (j < endj)
6586         {
6587                 // quickly skip over non-visible surfaces
6588                 for (;j < endj && !r_refdef.viewcache.world_surfacevisible[j];j++)
6589                         ;
6590                 // quickly iterate over visible surfaces
6591                 for (;j < endj && r_refdef.viewcache.world_surfacevisible[j];j++)
6592                 {
6593                         // process this surface
6594                         surface = model->data_surfaces + j;
6595                         // if this surface fits the criteria, add it to the list
6596                         if (surface->num_triangles)
6597                         {
6598                                 // if lightmap parameters changed, rebuild lightmap texture
6599                                 if (surface->cached_dlight)
6600                                         R_BuildLightMap(r_refdef.scene.worldentity, surface);
6601                                 // add face to draw list
6602                                 surfacelist[numsurfacelist++] = surface;
6603                                 r_refdef.stats.world_triangles += surface->num_triangles;
6604                                 if (numsurfacelist >= maxsurfacelist)
6605                                 {
6606                                         r_refdef.stats.world_surfaces += numsurfacelist;
6607                                         R_QueueSurfaceList(r_refdef.scene.worldentity, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
6608                                         numsurfacelist = 0;
6609                                 }
6610                         }
6611                 }
6612         }
6613         r_refdef.stats.world_surfaces += numsurfacelist;
6614         if (numsurfacelist)
6615                 R_QueueSurfaceList(r_refdef.scene.worldentity, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
6616         GL_AlphaTest(false);
6617 }
6618
6619 void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes, qboolean debug)
6620 {
6621         int i, j, f, flagsmask;
6622         msurface_t *surface, *endsurface;
6623         texture_t *t;
6624         model_t *model = ent->model;
6625         const int maxsurfacelist = 1024;
6626         int numsurfacelist = 0;
6627         msurface_t *surfacelist[1024];
6628         if (model == NULL)
6629                 return;
6630
6631         // if the model is static it doesn't matter what value we give for
6632         // wantnormals and wanttangents, so this logic uses only rules applicable
6633         // to a model, knowing that they are meaningless otherwise
6634         if (ent == r_refdef.scene.worldentity)
6635                 RSurf_ActiveWorldEntity();
6636         else if ((ent->effects & EF_FULLBRIGHT) || r_showsurfaces.integer || VectorLength2(ent->modellight_diffuse) < (1.0f / 256.0f))
6637                 RSurf_ActiveModelEntity(ent, false, false);
6638         else
6639                 RSurf_ActiveModelEntity(ent, true, r_glsl.integer && gl_support_fragment_shader && !depthonly);
6640
6641         // update light styles
6642         if (!skysurfaces && !depthonly && !addwaterplanes && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
6643         {
6644                 model_brush_lightstyleinfo_t *style;
6645                 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
6646                 {
6647                         if (style->value != r_refdef.scene.lightstylevalue[style->style])
6648                         {
6649                                 msurface_t *surfaces = model->data_surfaces;
6650                                 int *list = style->surfacelist;
6651                                 style->value = r_refdef.scene.lightstylevalue[style->style];
6652                                 for (j = 0;j < style->numsurfaces;j++)
6653                                         surfaces[list[j]].cached_dlight = true;
6654                         }
6655                 }
6656         }
6657
6658         R_UpdateAllTextureInfo(ent);
6659         flagsmask = addwaterplanes ? (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) : (skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL));
6660
6661         if (debug)
6662         {
6663                 R_DrawDebugModel(ent);
6664                 return;
6665         }
6666
6667         f = 0;
6668         t = NULL;
6669         rsurface.uselightmaptexture = false;
6670         rsurface.texture = NULL;
6671         rsurface.rtlight = NULL;
6672         numsurfacelist = 0;
6673         surface = model->data_surfaces + model->firstmodelsurface;
6674         endsurface = surface + model->nummodelsurfaces;
6675         for (;surface < endsurface;surface++)
6676         {
6677                 // if this surface fits the criteria, add it to the list
6678                 if (surface->num_triangles)
6679                 {
6680                         // if lightmap parameters changed, rebuild lightmap texture
6681                         if (surface->cached_dlight)
6682                                 R_BuildLightMap(ent, surface);
6683                         // add face to draw list
6684                         surfacelist[numsurfacelist++] = surface;
6685                         r_refdef.stats.entities_triangles += surface->num_triangles;
6686                         if (numsurfacelist >= maxsurfacelist)
6687                         {
6688                                 r_refdef.stats.entities_surfaces += numsurfacelist;
6689                                 R_QueueSurfaceList(ent, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
6690                                 numsurfacelist = 0;
6691                         }
6692                 }
6693         }
6694         r_refdef.stats.entities_surfaces += numsurfacelist;
6695         if (numsurfacelist)
6696                 R_QueueSurfaceList(ent, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
6697         GL_AlphaTest(false);
6698 }