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 #include "ft2.h"
  28
  29 mempool_t *r_main_mempool;
  30 rtexturepool_t *r_main_texturepool;
  31
  32 static int r_frame = 0; ///< used only by R_GetCurrentTexture
  33
  34 qboolean r_loadnormalmap;
  35 qboolean r_loadgloss;
  36 qboolean r_loadfog;
  37
  38 //
  39 // screen size info
  40 //
  41 r_refdef_t r_refdef;
  42
  43 cvar_t r_motionblur = {CVAR_SAVE, "r_motionblur", "0", "motionblur value scale - 0.5 recommended"};
  44 cvar_t r_damageblur = {CVAR_SAVE, "r_damageblur", "0", "motionblur based on damage"};
  45 cvar_t r_motionblur_vmin = {CVAR_SAVE, "r_motionblur_vmin", "300", "minimum influence from velocity"};
  46 cvar_t r_motionblur_vmax = {CVAR_SAVE, "r_motionblur_vmax", "600", "maximum influence from velocity"};
  47 cvar_t r_motionblur_bmin = {CVAR_SAVE, "r_motionblur_bmin", "0.5", "velocity at which there is no blur yet (may be negative to always have some blur)"};
  48 cvar_t r_motionblur_vcoeff = {CVAR_SAVE, "r_motionblur_vcoeff", "0.05", "sliding average reaction time for velocity"};
  49 cvar_t r_motionblur_maxblur = {CVAR_SAVE, "r_motionblur_maxblur", "0.88", "cap for motionblur alpha value"};
  50 cvar_t r_motionblur_randomize = {CVAR_SAVE, "r_motionblur_randomize", "0.1", "randomizing coefficient to workaround ghosting"};
  51
  52 // TODO do we want a r_equalize_entities cvar that works on all ents, or would that be a cheat?
  53 cvar_t r_equalize_entities_fullbright = {CVAR_SAVE, "r_equalize_entities_fullbright", "0", "render fullbright entities by equalizing their lightness, not by not rendering light"};
  54 cvar_t r_equalize_entities_minambient = {CVAR_SAVE, "r_equalize_entities_minambient", "0.5", "light equalizing: ensure at least this ambient/diffuse ratio"};
  55 cvar_t r_equalize_entities_by = {CVAR_SAVE, "r_equalize_entities_by", "0.7", "light equalizing: exponent of dynamics compression (0 = no compression, 1 = full compression)"};
  56 cvar_t r_equalize_entities_to = {CVAR_SAVE, "r_equalize_entities_to", "0.8", "light equalizing: target light level"};
  57
  58 cvar_t r_depthfirst = {CVAR_SAVE, "r_depthfirst", "0", "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"};
  59 cvar_t r_useinfinitefarclip = {CVAR_SAVE, "r_useinfinitefarclip", "1", "enables use of a special kind of projection matrix that has an extremely large farclip"};
  60 cvar_t r_farclip_base = {0, "r_farclip_base", "65536", "farclip (furthest visible distance) for rendering when r_useinfinitefarclip is 0"};
  61 cvar_t r_farclip_world = {0, "r_farclip_world", "2", "adds map size to farclip multiplied by this value"};
  62 cvar_t r_nearclip = {0, "r_nearclip", "1", "distance from camera of nearclip plane" };
  63 cvar_t r_showbboxes = {0, "r_showbboxes", "0", "shows bounding boxes of server entities, value controls opacity scaling (1 = 10%,  10 = 100%)"};
  64 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)"};
  65 cvar_t r_showtris = {0, "r_showtris", "0", "shows triangle outlines, value controls brightness (can be above 1)"};
  66 cvar_t r_shownormals = {0, "r_shownormals", "0", "shows per-vertex surface normals and tangent vectors for bumpmapped lighting"};
  67 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"};
  68 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"};
  69 cvar_t r_showcollisionbrushes = {0, "r_showcollisionbrushes", "0", "draws collision brushes in quake3 maps (mode 1), mode 2 disables rendering of world (trippy!)"};
  70 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"};
  71 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"};
  72 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"};
  73 cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating polygons) in world interior in quake1 maps"};
  74 cvar_t r_drawentities = {0, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"};
  75 cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1", "draw your weapon model"};
  76 cvar_t r_cullentities_trace = {0, "r_cullentities_trace", "1", "probabistically cull invisible entities"};
  77 cvar_t r_cullentities_trace_samples = {0, "r_cullentities_trace_samples", "2", "number of samples to test for entity culling (in addition to center sample)"};
  78 cvar_t r_cullentities_trace_tempentitysamples = {0, "r_cullentities_trace_tempentitysamples", "-1", "number of samples to test for entity culling of temp entities (including all CSQC entities), -1 disables trace culling on these entities to prevent flicker (pvs still applies)"};
  79 cvar_t r_cullentities_trace_enlarge = {0, "r_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
  80 cvar_t r_cullentities_trace_delay = {0, "r_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
  81 cvar_t r_speeds = {0, "r_speeds","0", "displays rendering statistics and per-subsystem timings"};
  82 cvar_t r_fullbright = {0, "r_fullbright","0", "makes map very bright and renders faster"};
  83 cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1", "opacity of water polygons"};
  84 cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1", "enables dynamic lights (rocket glow and such)"};
  85 cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1", "enables glowing pixels in quake textures (changes need r_restart to take effect)"};
  86 cvar_t r_shadows = {CVAR_SAVE, "r_shadows", "0", "casts fake stencil shadows from models onto the world (rtlights are unaffected by this); when set to 2, always cast the shadows in the direction set by r_shadows_throwdirection, otherwise use the model lighting."};
  87 cvar_t r_shadows_darken = {CVAR_SAVE, "r_shadows_darken", "0.5", "how much shadowed areas will be darkened"};
  88 cvar_t r_shadows_throwdistance = {CVAR_SAVE, "r_shadows_throwdistance", "500", "how far to cast shadows from models"};
  89 cvar_t r_shadows_throwdirection = {CVAR_SAVE, "r_shadows_throwdirection", "0 0 -1", "override throwing direction for r_shadows 2"};
  90 cvar_t r_shadows_drawafterrtlighting = {CVAR_SAVE, "r_shadows_drawafterrtlighting", "0", "draw fake shadows AFTER realtime lightning is drawn. May be useful for simulating fast sunlight on large outdoor maps with only one noshadow rtlight. The price is less realistic appearance of dynamic light shadows."};
  91 cvar_t r_shadows_castfrombmodels = {CVAR_SAVE, "r_shadows_castfrombmodels", "0", "do cast shadows from bmodels"};
  92 cvar_t r_q1bsp_skymasking = {0, "r_q1bsp_skymasking", "1", "allows sky polygons in quake1 maps to obscure other geometry"};
  93 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"};
  94 cvar_t r_polygonoffset_submodel_offset = {0, "r_polygonoffset_submodel_offset", "14", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
  95 cvar_t r_polygonoffset_decals_factor = {0, "r_polygonoffset_decals_factor", "0", "biases depth values of decals to prevent z-fighting artifacts"};
  96 cvar_t r_polygonoffset_decals_offset = {0, "r_polygonoffset_decals_offset", "-14", "biases depth values of decals to prevent z-fighting artifacts"};
  97 cvar_t r_fog_exp2 = {0, "r_fog_exp2", "0", "uses GL_EXP2 fog (as in Nehahra) rather than realistic GL_EXP fog"};
  98 cvar_t r_drawfog = {CVAR_SAVE, "r_drawfog", "1", "allows one to disable fog rendering"};
  99 cvar_t r_transparentdepthmasking = {CVAR_SAVE, "r_transparentdepthmasking", "0", "enables depth writes on transparent meshes whose materially is normally opaque, this prevents seeing the inside of a transparent mesh"};
 100
 101 cvar_t gl_fogenable = {0, "gl_fogenable", "0", "nehahra fog enable (for Nehahra compatibility only)"};
 102 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25", "nehahra fog density (recommend values below 0.1) (for Nehahra compatibility only)"};
 103 cvar_t gl_fogred = {0, "gl_fogred","0.3", "nehahra fog color red value (for Nehahra compatibility only)"};
 104 cvar_t gl_foggreen = {0, "gl_foggreen","0.3", "nehahra fog color green value (for Nehahra compatibility only)"};
 105 cvar_t gl_fogblue = {0, "gl_fogblue","0.3", "nehahra fog color blue value (for Nehahra compatibility only)"};
 106 cvar_t gl_fogstart = {0, "gl_fogstart", "0", "nehahra fog start distance (for Nehahra compatibility only)"};
 107 cvar_t gl_fogend = {0, "gl_fogend","0", "nehahra fog end distance (for Nehahra compatibility only)"};
 108 cvar_t gl_skyclip = {0, "gl_skyclip", "4608", "nehahra farclip distance - the real fog end (for Nehahra compatibility only)"};
 109
 110 cvar_t r_textureunits = {0, "r_textureunits", "32", "number of texture units to use in GL 1.1 and GL 1.3 rendering paths"};
 111 static cvar_t gl_combine = {CVAR_READONLY, "gl_combine", "1", "indicates whether the OpenGL 1.3 rendering path is active"};
 112 static cvar_t r_glsl = {CVAR_READONLY, "r_glsl", "1", "indicates whether the OpenGL 2.0 rendering path is active"};
 113
 114 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)"};
 115 cvar_t r_glsl_offsetmapping = {CVAR_SAVE, "r_glsl_offsetmapping", "0", "offset mapping effect (also known as parallax mapping or virtual displacement mapping)"};
 116 cvar_t r_glsl_offsetmapping_reliefmapping = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"};
 117 cvar_t r_glsl_offsetmapping_scale = {CVAR_SAVE, "r_glsl_offsetmapping_scale", "0.04", "how deep the offset mapping effect is"};
 118 cvar_t r_glsl_postprocess = {CVAR_SAVE, "r_glsl_postprocess", "0", "use a GLSL postprocessing shader"};
 119 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)"};
 120 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)"};
 121 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)"};
 122 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)"};
 123
 124 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)"};
 125 cvar_t r_water_clippingplanebias = {CVAR_SAVE, "r_water_clippingplanebias", "1", "a rather technical setting which avoids black pixels around water edges"};
 126 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"};
 127 cvar_t r_water_refractdistort = {CVAR_SAVE, "r_water_refractdistort", "0.01", "how much water refractions shimmer"};
 128 cvar_t r_water_reflectdistort = {CVAR_SAVE, "r_water_reflectdistort", "0.01", "how much water reflections shimmer"};
 129
 130 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "1", "enables animation smoothing on sprites"};
 131 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"};
 132 cvar_t r_lerplightstyles = {CVAR_SAVE, "r_lerplightstyles", "0", "enable animation smoothing on flickering lights"};
 133 cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1", "makes water scroll around, value controls how much"};
 134
 135 cvar_t r_bloom = {CVAR_SAVE, "r_bloom", "0", "enables bloom effect (makes bright pixels affect neighboring pixels)"};
 136 cvar_t r_bloom_colorscale = {CVAR_SAVE, "r_bloom_colorscale", "1", "how bright the glow is"};
 137 cvar_t r_bloom_brighten = {CVAR_SAVE, "r_bloom_brighten", "2", "how bright the glow is, after subtract/power"};
 138 cvar_t r_bloom_blur = {CVAR_SAVE, "r_bloom_blur", "4", "how large the glow is"};
 139 cvar_t r_bloom_resolution = {CVAR_SAVE, "r_bloom_resolution", "320", "what resolution to perform the bloom effect at (independent of screen resolution)"};
 140 cvar_t r_bloom_colorexponent = {CVAR_SAVE, "r_bloom_colorexponent", "1", "how exagerated the glow is"};
 141 cvar_t r_bloom_colorsubtract = {CVAR_SAVE, "r_bloom_colorsubtract", "0.125", "reduces bloom colors by a certain amount"};
 142
 143 cvar_t r_hdr = {CVAR_SAVE, "r_hdr", "0", "enables High Dynamic Range bloom effect (higher quality version of r_bloom)"};
 144 cvar_t r_hdr_scenebrightness = {CVAR_SAVE, "r_hdr_scenebrightness", "1", "global rendering brightness"};
 145 cvar_t r_hdr_glowintensity = {CVAR_SAVE, "r_hdr_glowintensity", "1", "how bright light emitting textures should appear"};
 146 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)"};
 147
 148 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"};
 149
 150 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"};
 151
 152 cvar_t gl_lightmaps = {0, "gl_lightmaps", "0", "draws only lightmaps, no texture (for level designers)"};
 153
 154 cvar_t r_test = {0, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"};
 155 cvar_t r_batchmode = {0, "r_batchmode", "1", "selects method of rendering multiple surfaces with one driver call (values are 0, 1, 2, etc...)"};
 156 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"};
 157 cvar_t r_track_sprites_flags = {CVAR_SAVE, "r_track_sprites_flags", "1", "1: Rotate sprites accodringly, 2: Make it a continuous rotation"};
 158 cvar_t r_track_sprites_scalew = {CVAR_SAVE, "r_track_sprites_scalew", "1", "width scaling of tracked sprites"};
 159 cvar_t r_track_sprites_scaleh = {CVAR_SAVE, "r_track_sprites_scaleh", "1", "height scaling of tracked sprites"};
 160 cvar_t r_glsl_saturation = {CVAR_SAVE, "r_glsl_saturation", "1", "saturation multiplier (only working in glsl!)"};
 161
 162 cvar_t r_framedatasize = {CVAR_SAVE, "r_framedatasize", "1", "size of renderer data cache used during one frame (for skeletal animation caching, light processing, etc)"};
 163
 164 extern cvar_t v_glslgamma;
 165
 166 extern qboolean v_flipped_state;
 167
 168 static struct r_bloomstate_s
 169 {
 170         qboolean enabled;
 171         qboolean hdr;
 172
 173         int bloomwidth, bloomheight;
 174
 175         int screentexturewidth, screentextureheight;
 176         rtexture_t *texture_screen; /// \note also used for motion blur if enabled!
 177
 178         int bloomtexturewidth, bloomtextureheight;
 179         rtexture_t *texture_bloom;
 180
 181         // arrays for rendering the screen passes
 182         float screentexcoord2f[8];
 183         float bloomtexcoord2f[8];
 184         float offsettexcoord2f[8];
 185
 186         r_viewport_t viewport;
 187 }
 188 r_bloomstate;
 189
 190 r_waterstate_t r_waterstate;
 191
 192 /// shadow volume bsp struct with automatically growing nodes buffer
 193 svbsp_t r_svbsp;
 194
 195 rtexture_t *r_texture_blanknormalmap;
 196 rtexture_t *r_texture_white;
 197 rtexture_t *r_texture_grey128;
 198 rtexture_t *r_texture_black;
 199 rtexture_t *r_texture_notexture;
 200 rtexture_t *r_texture_whitecube;
 201 rtexture_t *r_texture_normalizationcube;
 202 rtexture_t *r_texture_fogattenuation;
 203 rtexture_t *r_texture_gammaramps;
 204 unsigned int r_texture_gammaramps_serial;
 205 //rtexture_t *r_texture_fogintensity;
 206
 207 unsigned int r_queries[MAX_OCCLUSION_QUERIES];
 208 unsigned int r_numqueries;
 209 unsigned int r_maxqueries;
 210
 211 typedef struct r_qwskincache_s
 212 {
 213         char name[MAX_QPATH];
 214         skinframe_t *skinframe;
 215 }
 216 r_qwskincache_t;
 217
 218 static r_qwskincache_t *r_qwskincache;
 219 static int r_qwskincache_size;
 220
 221 /// vertex coordinates for a quad that covers the screen exactly
 222 const float r_screenvertex3f[12] =
 223 {
 224         0, 0, 0,
 225         1, 0, 0,
 226         1, 1, 0,
 227         0, 1, 0
 228 };
 229
 230 extern void R_DrawModelShadows(void);
 231
 232 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
 233 {
 234         int i;
 235         for (i = 0;i < verts;i++)
 236         {
 237                 out[0] = in[0] * r;
 238                 out[1] = in[1] * g;
 239                 out[2] = in[2] * b;
 240                 out[3] = in[3];
 241                 in += 4;
 242                 out += 4;
 243         }
 244 }
 245
 246 void R_FillColors(float *out, int verts, float r, float g, float b, float a)
 247 {
 248         int i;
 249         for (i = 0;i < verts;i++)
 250         {
 251                 out[0] = r;
 252                 out[1] = g;
 253                 out[2] = b;
 254                 out[3] = a;
 255                 out += 4;
 256         }
 257 }
 258
 259 // FIXME: move this to client?
 260 void FOG_clear(void)
 261 {
 262         if (gamemode == GAME_NEHAHRA)
 263         {
 264                 Cvar_Set("gl_fogenable", "0");
 265                 Cvar_Set("gl_fogdensity", "0.2");
 266                 Cvar_Set("gl_fogred", "0.3");
 267                 Cvar_Set("gl_foggreen", "0.3");
 268                 Cvar_Set("gl_fogblue", "0.3");
 269         }
 270         r_refdef.fog_density = 0;
 271         r_refdef.fog_red = 0;
 272         r_refdef.fog_green = 0;
 273         r_refdef.fog_blue = 0;
 274         r_refdef.fog_alpha = 1;
 275         r_refdef.fog_start = 0;
 276         r_refdef.fog_end = 16384;
 277         r_refdef.fog_height = 1<<30;
 278         r_refdef.fog_fadedepth = 128;
 279 }
 280
 281 static void R_BuildBlankTextures(void)
 282 {
 283         unsigned char data[4];
 284         data[2] = 128; // normal X
 285         data[1] = 128; // normal Y
 286         data[0] = 255; // normal Z
 287         data[3] = 128; // height
 288         r_texture_blanknormalmap = R_LoadTexture2D(r_main_texturepool, "blankbump", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, NULL);
 289         data[0] = 255;
 290         data[1] = 255;
 291         data[2] = 255;
 292         data[3] = 255;
 293         r_texture_white = R_LoadTexture2D(r_main_texturepool, "blankwhite", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, NULL);
 294         data[0] = 128;
 295         data[1] = 128;
 296         data[2] = 128;
 297         data[3] = 255;
 298         r_texture_grey128 = R_LoadTexture2D(r_main_texturepool, "blankgrey128", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, NULL);
 299         data[0] = 0;
 300         data[1] = 0;
 301         data[2] = 0;
 302         data[3] = 255;
 303         r_texture_black = R_LoadTexture2D(r_main_texturepool, "blankblack", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, NULL);
 304 }
 305
 306 static void R_BuildNoTexture(void)
 307 {
 308         int x, y;
 309         unsigned char pix[16][16][4];
 310         // this makes a light grey/dark grey checkerboard texture
 311         for (y = 0;y < 16;y++)
 312         {
 313                 for (x = 0;x < 16;x++)
 314                 {
 315                         if ((y < 8) ^ (x < 8))
 316                         {
 317                                 pix[y][x][0] = 128;
 318                                 pix[y][x][1] = 128;
 319                                 pix[y][x][2] = 128;
 320                                 pix[y][x][3] = 255;
 321                         }
 322                         else
 323                         {
 324                                 pix[y][x][0] = 64;
 325                                 pix[y][x][1] = 64;
 326                                 pix[y][x][2] = 64;
 327                                 pix[y][x][3] = 255;
 328                         }
 329                 }
 330         }
 331         r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_BGRA, TEXF_MIPMAP | TEXF_PERSISTENT, NULL);
 332 }
 333
 334 static void R_BuildWhiteCube(void)
 335 {
 336         unsigned char data[6*1*1*4];
 337         memset(data, 255, sizeof(data));
 338         r_texture_whitecube = R_LoadTextureCubeMap(r_main_texturepool, "whitecube", 1, data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_PERSISTENT, NULL);
 339 }
 340
 341 static void R_BuildNormalizationCube(void)
 342 {
 343         int x, y, side;
 344         vec3_t v;
 345         vec_t s, t, intensity;
 346 #define NORMSIZE 64
 347         unsigned char *data;
 348         data = Mem_Alloc(tempmempool, 6*NORMSIZE*NORMSIZE*4);
 349         for (side = 0;side < 6;side++)
 350         {
 351                 for (y = 0;y < NORMSIZE;y++)
 352                 {
 353                         for (x = 0;x < NORMSIZE;x++)
 354                         {
 355                                 s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
 356                                 t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
 357                                 switch(side)
 358                                 {
 359                                 default:
 360                                 case 0:
 361                                         v[0] = 1;
 362                                         v[1] = -t;
 363                                         v[2] = -s;
 364                                         break;
 365                                 case 1:
 366                                         v[0] = -1;
 367                                         v[1] = -t;
 368                                         v[2] = s;
 369                                         break;
 370                                 case 2:
 371                                         v[0] = s;
 372                                         v[1] = 1;
 373                                         v[2] = t;
 374                                         break;
 375                                 case 3:
 376                                         v[0] = s;
 377                                         v[1] = -1;
 378                                         v[2] = -t;
 379                                         break;
 380                                 case 4:
 381                                         v[0] = s;
 382                                         v[1] = -t;
 383                                         v[2] = 1;
 384                                         break;
 385                                 case 5:
 386                                         v[0] = -s;
 387                                         v[1] = -t;
 388                                         v[2] = -1;
 389                                         break;
 390                                 }
 391                                 intensity = 127.0f / sqrt(DotProduct(v, v));
 392                                 data[((side*64+y)*64+x)*4+2] = (unsigned char)(128.0f + intensity * v[0]);
 393                                 data[((side*64+y)*64+x)*4+1] = (unsigned char)(128.0f + intensity * v[1]);
 394                                 data[((side*64+y)*64+x)*4+0] = (unsigned char)(128.0f + intensity * v[2]);
 395                                 data[((side*64+y)*64+x)*4+3] = 255;
 396                         }
 397                 }
 398         }
 399         r_texture_normalizationcube = R_LoadTextureCubeMap(r_main_texturepool, "normalcube", NORMSIZE, data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_PERSISTENT, NULL);
 400         Mem_Free(data);
 401 }
 402
 403 static void R_BuildFogTexture(void)
 404 {
 405         int x, b;
 406 #define FOGWIDTH 256
 407         unsigned char data1[FOGWIDTH][4];
 408         //unsigned char data2[FOGWIDTH][4];
 409         double d, r, alpha;
 410
 411         r_refdef.fogmasktable_start = r_refdef.fog_start;
 412         r_refdef.fogmasktable_alpha = r_refdef.fog_alpha;
 413         r_refdef.fogmasktable_range = r_refdef.fogrange;
 414         r_refdef.fogmasktable_density = r_refdef.fog_density;
 415
 416         r = r_refdef.fogmasktable_range / FOGMASKTABLEWIDTH;
 417         for (x = 0;x < FOGMASKTABLEWIDTH;x++)
 418         {
 419                 d = (x * r - r_refdef.fogmasktable_start);
 420                 if(developer.integer >= 100)
 421                         Con_Printf("%f ", d);
 422                 d = max(0, d);
 423                 if (r_fog_exp2.integer)
 424                         alpha = exp(-r_refdef.fogmasktable_density * r_refdef.fogmasktable_density * 0.0001 * d * d);
 425                 else
 426                         alpha = exp(-r_refdef.fogmasktable_density * 0.004 * d);
 427                 if(developer.integer >= 100)
 428                         Con_Printf(" : %f ", alpha);
 429                 alpha = 1 - (1 - alpha) * r_refdef.fogmasktable_alpha;
 430                 if(developer.integer >= 100)
 431                         Con_Printf(" = %f\n", alpha);
 432                 r_refdef.fogmasktable[x] = bound(0, alpha, 1);
 433         }
 434
 435         for (x = 0;x < FOGWIDTH;x++)
 436         {
 437                 b = (int)(r_refdef.fogmasktable[x * (FOGMASKTABLEWIDTH - 1) / (FOGWIDTH - 1)] * 255);
 438                 data1[x][0] = b;
 439                 data1[x][1] = b;
 440                 data1[x][2] = b;
 441                 data1[x][3] = 255;
 442                 //data2[x][0] = 255 - b;
 443                 //data2[x][1] = 255 - b;
 444                 //data2[x][2] = 255 - b;
 445                 //data2[x][3] = 255;
 446         }
 447         if (r_texture_fogattenuation)
 448         {
 449                 R_UpdateTexture(r_texture_fogattenuation, &data1[0][0], 0, 0, FOGWIDTH, 1);
 450                 //R_UpdateTexture(r_texture_fogattenuation, &data2[0][0], 0, 0, FOGWIDTH, 1);
 451         }
 452         else
 453         {
 454                 r_texture_fogattenuation = R_LoadTexture2D(r_main_texturepool, "fogattenuation", FOGWIDTH, 1, &data1[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT | TEXF_ALLOWUPDATES, NULL);
 455                 //r_texture_fogintensity = R_LoadTexture2D(r_main_texturepool, "fogintensity", FOGWIDTH, 1, &data2[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALLOWUPDATES, NULL);
 456         }
 457 }
 458
 459 static const char *builtinshaderstring =
 460 "// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
 461 "// written by Forest 'LordHavoc' Hale\n"
 462 "\n"
 463 "// enable various extensions depending on permutation:\n"
 464 "\n"
 465 "#ifdef VERTEX_SHADER\n"
 466 "uniform mat4 ModelViewProjectionMatrix;\n"
 467 "#endif\n"
 468 "\n"
 469 "#ifdef MODE_DEPTH_OR_SHADOW\n"
 470 "#ifdef VERTEX_SHADER\n"
 471 "void main(void)\n"
 472 "{\n"
 473 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 474 "}\n"
 475 "#endif\n"
 476 "#else // !MODE_DEPTH_ORSHADOW\n"
 477 "#ifdef MODE_SHOWDEPTH\n"
 478 "#ifdef VERTEX_SHADER\n"
 479 "void main(void)\n"
 480 "{\n"
 481 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 482 "       gl_FrontColor = vec4(gl_Position.z, gl_Position.z, gl_Position.z, 1.0);\n"
 483 "}\n"
 484 "#endif\n"
 485 "\n"
 486 "#ifdef FRAGMENT_SHADER\n"
 487 "void main(void)\n"
 488 "{\n"
 489 "       gl_FragColor = gl_Color;\n"
 490 "}\n"
 491 "#endif\n"
 492 "#else // !MODE_SHOWDEPTH\n"
 493 "#ifdef MODE_POSTPROCESS\n"
 494 "varying vec2 TexCoord1;\n"
 495 "varying vec2 TexCoord2;\n"
 496 "\n"
 497 "#ifdef VERTEX_SHADER\n"
 498 "void main(void)\n"
 499 "{\n"
 500 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 501 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
 502 "#ifdef USEBLOOM\n"
 503 "       TexCoord2 = gl_MultiTexCoord1.xy;\n"
 504 "#endif\n"
 505 "}\n"
 506 "#endif\n"
 507 "\n"
 508 "#ifdef FRAGMENT_SHADER\n"
 509 "uniform sampler2D Texture_First;\n"
 510 "#ifdef USEBLOOM\n"
 511 "uniform sampler2D Texture_Second;\n"
 512 "#endif\n"
 513 "#ifdef USEGAMMARAMPS\n"
 514 "uniform sampler2D Texture_GammaRamps;\n"
 515 "#endif\n"
 516 "#ifdef USESATURATION\n"
 517 "uniform float Saturation;\n"
 518 "#endif\n"
 519 "#ifdef USEVIEWTINT\n"
 520 "uniform vec4 ViewTintColor;\n"
 521 "#endif\n"
 522 "//uncomment these if you want to use them:\n"
 523 "uniform vec4 UserVec1;\n"
 524 "// uniform vec4 UserVec2;\n"
 525 "// uniform vec4 UserVec3;\n"
 526 "// uniform vec4 UserVec4;\n"
 527 "// uniform float ClientTime;\n"
 528 "uniform vec2 PixelSize;\n"
 529 "void main(void)\n"
 530 "{\n"
 531 "       gl_FragColor = texture2D(Texture_First, TexCoord1);\n"
 532 "#ifdef USEBLOOM\n"
 533 "       gl_FragColor += texture2D(Texture_Second, TexCoord2);\n"
 534 "#endif\n"
 535 "#ifdef USEVIEWTINT\n"
 536 "       gl_FragColor = mix(gl_FragColor, ViewTintColor, ViewTintColor.a);\n"
 537 "#endif\n"
 538 "\n"
 539 "#ifdef USEPOSTPROCESSING\n"
 540 "// do r_glsl_dumpshader, edit glsl/default.glsl, and replace this by your own postprocessing if you want\n"
 541 "// this code does a blur with the radius specified in the first component of r_glsl_postprocess_uservec1 and blends it using the second component\n"
 542 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.987688, -0.156434)) * UserVec1.y;\n"
 543 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.156434, -0.891007)) * UserVec1.y;\n"
 544 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2( 0.891007, -0.453990)) * UserVec1.y;\n"
 545 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2( 0.707107,  0.707107)) * UserVec1.y;\n"
 546 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.453990,  0.891007)) * UserVec1.y;\n"
 547 "       gl_FragColor /= (1 + 5 * UserVec1.y);\n"
 548 "#endif\n"
 549 "\n"
 550 "#ifdef USESATURATION\n"
 551 "       //apply saturation BEFORE gamma ramps, so v_glslgamma value does not matter\n"
 552 "       float y = dot(gl_FragColor.rgb, vec3(0.299, 0.587, 0.114));\n"
 553 "       //gl_FragColor = vec3(y) + (gl_FragColor.rgb - vec3(y)) * Saturation;\n"
 554 "       gl_FragColor.rgb = mix(vec3(y), gl_FragColor.rgb, Saturation);\n"
 555 "#endif\n"
 556 "\n"
 557 "#ifdef USEGAMMARAMPS\n"
 558 "       gl_FragColor.r = texture2D(Texture_GammaRamps, vec2(gl_FragColor.r, 0)).r;\n"
 559 "       gl_FragColor.g = texture2D(Texture_GammaRamps, vec2(gl_FragColor.g, 0)).g;\n"
 560 "       gl_FragColor.b = texture2D(Texture_GammaRamps, vec2(gl_FragColor.b, 0)).b;\n"
 561 "#endif\n"
 562 "}\n"
 563 "#endif\n"
 564 "#else // !MODE_POSTPROCESS\n"
 565 "#ifdef MODE_GENERIC\n"
 566 "#ifdef USEDIFFUSE\n"
 567 "varying vec2 TexCoord1;\n"
 568 "#endif\n"
 569 "#ifdef USESPECULAR\n"
 570 "varying vec2 TexCoord2;\n"
 571 "#endif\n"
 572 "#ifdef VERTEX_SHADER\n"
 573 "void main(void)\n"
 574 "{\n"
 575 "       gl_FrontColor = gl_Color;\n"
 576 "#ifdef USEDIFFUSE\n"
 577 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
 578 "#endif\n"
 579 "#ifdef USESPECULAR\n"
 580 "       TexCoord2 = gl_MultiTexCoord1.xy;\n"
 581 "#endif\n"
 582 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 583 "}\n"
 584 "#endif\n"
 585 "\n"
 586 "#ifdef FRAGMENT_SHADER\n"
 587 "#ifdef USEDIFFUSE\n"
 588 "uniform sampler2D Texture_First;\n"
 589 "#endif\n"
 590 "#ifdef USESPECULAR\n"
 591 "uniform sampler2D Texture_Second;\n"
 592 "#endif\n"
 593 "\n"
 594 "void main(void)\n"
 595 "{\n"
 596 "       gl_FragColor = gl_Color;\n"
 597 "#ifdef USEDIFFUSE\n"
 598 "       gl_FragColor *= texture2D(Texture_First, TexCoord1);\n"
 599 "#endif\n"
 600 "\n"
 601 "#ifdef USESPECULAR\n"
 602 "       vec4 tex2 = texture2D(Texture_Second, TexCoord2);\n"
 603 "# ifdef USECOLORMAPPING\n"
 604 "       gl_FragColor *= tex2;\n"
 605 "# endif\n"
 606 "# ifdef USEGLOW\n"
 607 "       gl_FragColor += tex2;\n"
 608 "# endif\n"
 609 "# ifdef USEVERTEXTEXTUREBLEND\n"
 610 "       gl_FragColor = mix(gl_FragColor, tex2, tex2.a);\n"
 611 "# endif\n"
 612 "#endif\n"
 613 "}\n"
 614 "#endif\n"
 615 "#else // !MODE_GENERIC\n"
 616 "#ifdef MODE_BLOOMBLUR\n"
 617 "varying TexCoord;\n"
 618 "#ifdef VERTEX_SHADER\n"
 619 "void main(void)\n"
 620 "{\n"
 621 "       gl_FrontColor = gl_Color;\n"
 622 "       TexCoord = gl_MultiTexCoord0.xy;\n"
 623 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 624 "}\n"
 625 "#endif\n"
 626 "\n"
 627 "#ifdef FRAGMENT_SHADER\n"
 628 "uniform sampler2D Texture_First;\n"
 629 "uniform vec4 BloomBlur_Parameters;\n"
 630 "\n"
 631 "void main(void)\n"
 632 "{\n"
 633 "       int i;\n"
 634 "       vec2 tc = TexCoord;\n"
 635 "       vec3 color = texture2D(Texture_First, tc).rgb;\n"
 636 "       tc += BloomBlur_Parameters.xy;\n"
 637 "       for (i = 1;i < SAMPLES;i++)\n"
 638 "       {\n"
 639 "               color += texture2D(Texture_First, tc).rgb;\n"
 640 "               tc += BloomBlur_Parameters.xy;\n"
 641 "       }\n"
 642 "       gl_FragColor = vec4(color * BloomBlur_Parameters.z + vec3(BloomBlur_Parameters.w), 1);\n"
 643 "}\n"
 644 "#endif\n"
 645 "#else // !MODE_BLOOMBLUR\n"
 646 "#ifdef MODE_REFRACTION\n"
 647 "varying vec2 TexCoord;\n"
 648 "varying vec4 ModelViewProjectionPosition;\n"
 649 "uniform mat4 TexMatrix;\n"
 650 "#ifdef VERTEX_SHADER\n"
 651 "\n"
 652 "void main(void)\n"
 653 "{\n"
 654 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
 655 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 656 "       ModelViewProjectionPosition = gl_Position;\n"
 657 "}\n"
 658 "#endif\n"
 659 "\n"
 660 "#ifdef FRAGMENT_SHADER\n"
 661 "uniform sampler2D Texture_Normal;\n"
 662 "uniform sampler2D Texture_Refraction;\n"
 663 "uniform sampler2D Texture_Reflection;\n"
 664 "\n"
 665 "uniform vec4 DistortScaleRefractReflect;\n"
 666 "uniform vec4 ScreenScaleRefractReflect;\n"
 667 "uniform vec4 ScreenCenterRefractReflect;\n"
 668 "uniform vec4 RefractColor;\n"
 669 "uniform vec4 ReflectColor;\n"
 670 "uniform float ReflectFactor;\n"
 671 "uniform float ReflectOffset;\n"
 672 "\n"
 673 "void main(void)\n"
 674 "{\n"
 675 "       vec2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
 676 "       //vec2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
 677 "       vec2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
 678 "       vec2 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xy * DistortScaleRefractReflect.xy;\n"
 679 "       // FIXME temporary hack to detect the case that the reflection\n"
 680 "       // gets blackened at edges due to leaving the area that contains actual\n"
 681 "       // content.\n"
 682 "       // Remove this 'ack once we have a better way to stop this thing from\n"
 683 "       // 'appening.\n"
 684 "       float f = min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(0.01, 0.01)).rgb) / 0.05);\n"
 685 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(0.01, -0.01)).rgb) / 0.05);\n"
 686 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
 687 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
 688 "       ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n"
 689 "       gl_FragColor = texture2D(Texture_Refraction, ScreenTexCoord) * RefractColor;\n"
 690 "}\n"
 691 "#endif\n"
 692 "#else // !MODE_REFRACTION\n"
 693 "#ifdef MODE_WATER\n"
 694 "varying vec2 TexCoord;\n"
 695 "varying vec3 EyeVector;\n"
 696 "varying vec4 ModelViewProjectionPosition;\n"
 697 "#ifdef VERTEX_SHADER\n"
 698 "uniform vec3 EyePosition;\n"
 699 "uniform mat4 TexMatrix;\n"
 700 "\n"
 701 "void main(void)\n"
 702 "{\n"
 703 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
 704 "       vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
 705 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
 706 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
 707 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
 708 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 709 "       ModelViewProjectionPosition = gl_Position;\n"
 710 "}\n"
 711 "#endif\n"
 712 "\n"
 713 "#ifdef FRAGMENT_SHADER\n"
 714 "uniform sampler2D Texture_Normal;\n"
 715 "uniform sampler2D Texture_Refraction;\n"
 716 "uniform sampler2D Texture_Reflection;\n"
 717 "\n"
 718 "uniform vec4 DistortScaleRefractReflect;\n"
 719 "uniform vec4 ScreenScaleRefractReflect;\n"
 720 "uniform vec4 ScreenCenterRefractReflect;\n"
 721 "uniform vec4 RefractColor;\n"
 722 "uniform vec4 ReflectColor;\n"
 723 "uniform float ReflectFactor;\n"
 724 "uniform float ReflectOffset;\n"
 725 "\n"
 726 "void main(void)\n"
 727 "{\n"
 728 "       vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
 729 "       //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
 730 "       vec4 SafeScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
 731 "       vec4 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
 732 "       // FIXME temporary hack to detect the case that the reflection\n"
 733 "       // gets blackened at edges due to leaving the area that contains actual\n"
 734 "       // content.\n"
 735 "       // Remove this 'ack once we have a better way to stop this thing from\n"
 736 "       // 'appening.\n"
 737 "       float f = min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.01, 0.01)).rgb) / 0.05);\n"
 738 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.01, -0.01)).rgb) / 0.05);\n"
 739 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
 740 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
 741 "       ScreenTexCoord.xy = mix(SafeScreenTexCoord.xy, ScreenTexCoord.xy, f);\n"
 742 "       f       = min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.01, 0.01)).rgb) / 0.05);\n"
 743 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.01, -0.01)).rgb) / 0.05);\n"
 744 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
 745 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
 746 "       ScreenTexCoord.zw = mix(SafeScreenTexCoord.zw, ScreenTexCoord.zw, f);\n"
 747 "       float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 2.0) * ReflectFactor + ReflectOffset;\n"
 748 "       gl_FragColor = mix(texture2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, texture2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n"
 749 "}\n"
 750 "#endif\n"
 751 "#else // !MODE_WATER\n"
 752 "\n"
 753 "#if defined(USESHADOWMAPRECT) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USEDEFERREDLIGHTMAP)\n"
 754 "# extension GL_ARB_texture_rectangle : enable\n"
 755 "#endif\n"
 756 "\n"
 757 "#ifdef USESHADOWMAP2D\n"
 758 "# ifdef GL_EXT_gpu_shader4\n"
 759 "#   extension GL_EXT_gpu_shader4 : enable\n"
 760 "# endif\n"
 761 "# ifdef GL_ARB_texture_gather\n"
 762 "#   extension GL_ARB_texture_gather : enable\n"
 763 "# else\n"
 764 "#   ifdef GL_AMD_texture_texture4\n"
 765 "#     extension GL_AMD_texture_texture4 : enable\n"
 766 "#   endif\n"
 767 "# endif\n"
 768 "#endif\n"
 769 "\n"
 770 "#ifdef USESHADOWMAPCUBE\n"
 771 "# extension GL_EXT_gpu_shader4 : enable\n"
 772 "#endif\n"
 773 "\n"
 774 "#ifdef USESHADOWSAMPLER\n"
 775 "# extension GL_ARB_shadow : enable\n"
 776 "#endif\n"
 777 "\n"
 778 "// common definitions between vertex shader and fragment shader:\n"
 779 "\n"
 780 "//#ifdef __GLSL_CG_DATA_TYPES\n"
 781 "//# define myhalf half\n"
 782 "//# define myhalf2 half2\n"
 783 "//# define myhalf3half3\n"
 784 "//# define myhalf4 half4\n"
 785 "//#else\n"
 786 "# define myhalf float\n"
 787 "# define myhalf2 vec2\n"
 788 "# define myhalf3 vec3\n"
 789 "# define myhalf4 vec4\n"
 790 "//#endif\n"
 791 "\n"
 792 "#if defined(USEFOGINSIDE) || defined(USEFOGOUTSIDE)\n"
 793 "# define USEFOG\n"
 794 "#endif\n"
 795 "\n"
 796 "varying vec2 TexCoord;\n"
 797 "#ifdef USEVERTEXTEXTUREBLEND\n"
 798 "varying vec2 TexCoord2;\n"
 799 "#endif\n"
 800 "#if defined(MODE_LIGHTMAP) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
 801 "#define USELIGHTMAP\n"
 802 "varying vec2 TexCoordLightmap;\n"
 803 "#endif\n"
 804 "\n"
 805 "#ifdef MODE_LIGHTSOURCE\n"
 806 "varying vec3 CubeVector;\n"
 807 "#endif\n"
 808 "\n"
 809 "#ifdef MODE_LIGHTSOURCE\n"
 810 "varying vec3 LightVector;\n"
 811 "#endif\n"
 812 "#if defined(MODE_LIGHTDIRECTION)\n"
 813 "varying vec3 LightVector;\n"
 814 "#endif\n"
 815 "\n"
 816 "#if defined(USEOFFSETMAPPING) || defined(USESPECULAR)\n"
 817 "//#if defined(USEOFFSETMAPPING) || defined(USESPECULAR) || defined(MODE_LIGHTDIRECTION) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
 818 "#define USEEYEVECTOR\n"
 819 "varying vec3 EyeVector;\n"
 820 "#endif\n"
 821 "#ifdef USEFOG\n"
 822 "varying vec3 EyeVectorModelSpace;\n"
 823 "varying float FogPlaneVertexDist;\n"
 824 "#endif\n"
 825 "\n"
 826 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY)\n"
 827 "varying vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n"
 828 "varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
 829 "varying vec3 VectorR; // direction of R texcoord (surface normal)\n"
 830 "#endif\n"
 831 "\n"
 832 "#ifdef USEREFLECTION\n"
 833 "varying vec4 ModelViewProjectionPosition;\n"
 834 "#endif\n"
 835 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
 836 "uniform vec3 LightPosition;\n"
 837 "varying vec4 ModelViewPosition;\n"
 838 "#endif\n"
 839 "\n"
 840 "#ifdef MODE_LIGHTSOURCE\n"
 841 "uniform vec3 LightPosition;\n"
 842 "#endif\n"
 843 "uniform vec3 EyePosition;\n"
 844 "#ifdef MODE_LIGHTDIRECTION\n"
 845 "uniform vec3 LightDir;\n"
 846 "#endif\n"
 847 "uniform vec4 FogPlane;\n"
 848 "\n"
 849 "\n"
 850 "\n"
 851 "\n"
 852 "\n"
 853 "// vertex shader specific:\n"
 854 "#ifdef VERTEX_SHADER\n"
 855 "\n"
 856 "// 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"
 857 "\n"
 858 "#ifdef MODE_DEFERREDGEOMETRY\n"
 859 "uniform mat4 TexMatrix;\n"
 860 "#ifdef USEVERTEXTEXTUREBLEND\n"
 861 "uniform mat4 BackgroundTexMatrix;\n"
 862 "#endif\n"
 863 "uniform mat4 ModelViewMatrix;\n"
 864 "void main(void)\n"
 865 "{\n"
 866 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
 867 "#ifdef USEVERTEXTEXTUREBLEND\n"
 868 "       gl_FrontColor = gl_Color;\n"
 869 "       TexCoord2 = vec2(BackgroundTexMatrix * gl_MultiTexCoord0);\n"
 870 "#endif\n"
 871 "\n"
 872 "       // transform unnormalized eye direction into tangent space\n"
 873 "#ifdef USEOFFSETMAPPING\n"
 874 "       vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
 875 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
 876 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
 877 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
 878 "#endif\n"
 879 "\n"
 880 "       VectorS = (ModelViewMatrix * vec4(gl_MultiTexCoord1.xyz, 0)).xyz;\n"
 881 "       VectorT = (ModelViewMatrix * vec4(gl_MultiTexCoord2.xyz, 0)).xyz;\n"
 882 "       VectorR = (ModelViewMatrix * vec4(gl_MultiTexCoord3.xyz, 0)).xyz;\n"
 883 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 884 "}\n"
 885 "#else // !MODE_DEFERREDGEOMETRY\n"
 886 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
 887 "uniform mat4 ModelViewMatrix;\n"
 888 "void main(void)\n"
 889 "{\n"
 890 "       ModelViewPosition = ModelViewMatrix * gl_Vertex;\n"
 891 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 892 "}\n"
 893 "#else // !MODE_DEFERREDLIGHTSOURCE\n"
 894 "uniform mat4 TexMatrix;\n"
 895 "#ifdef USEVERTEXTEXTUREBLEND\n"
 896 "uniform mat4 BackgroundTexMatrix;\n"
 897 "#endif\n"
 898 "#ifdef MODE_LIGHTSOURCE\n"
 899 "uniform mat4 ModelToLight;\n"
 900 "#endif\n"
 901 "void main(void)\n"
 902 "{\n"
 903 "#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n"
 904 "       gl_FrontColor = gl_Color;\n"
 905 "#endif\n"
 906 "       // copy the surface texcoord\n"
 907 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
 908 "#ifdef USEVERTEXTEXTUREBLEND\n"
 909 "       TexCoord2 = vec2(BackgroundTexMatrix * gl_MultiTexCoord0);\n"
 910 "#endif\n"
 911 "#ifdef USELIGHTMAP\n"
 912 "       TexCoordLightmap = vec2(gl_MultiTexCoord4);\n"
 913 "#endif\n"
 914 "\n"
 915 "#ifdef MODE_LIGHTSOURCE\n"
 916 "       // transform vertex position into light attenuation/cubemap space\n"
 917 "       // (-1 to +1 across the light box)\n"
 918 "       CubeVector = vec3(ModelToLight * gl_Vertex);\n"
 919 "\n"
 920 "# ifdef USEDIFFUSE\n"
 921 "       // transform unnormalized light direction into tangent space\n"
 922 "       // (we use unnormalized to ensure that it interpolates correctly and then\n"
 923 "       //  normalize it per pixel)\n"
 924 "       vec3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
 925 "       LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
 926 "       LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
 927 "       LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
 928 "# endif\n"
 929 "#endif\n"
 930 "\n"
 931 "#if defined(MODE_LIGHTDIRECTION) && defined(USEDIFFUSE)\n"
 932 "       LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);\n"
 933 "       LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);\n"
 934 "       LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);\n"
 935 "#endif\n"
 936 "\n"
 937 "       // transform unnormalized eye direction into tangent space\n"
 938 "#ifdef USEEYEVECTOR\n"
 939 "#ifndef USEFOG\n"
 940 "       vec3 EyeVectorModelSpace;\n"
 941 "#endif\n"
 942 "       EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
 943 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
 944 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
 945 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
 946 "#endif\n"
 947 "\n"
 948 "#ifdef USEFOG\n"
 949 "#ifndef USEEYEVECTOR\n"
 950 "       EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
 951 "#endif\n"
 952 "       FogPlaneVertexDist = dot(FogPlane, gl_Vertex);\n"
 953 "#endif\n"
 954 "\n"
 955 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
 956 "       VectorS = gl_MultiTexCoord1.xyz;\n"
 957 "       VectorT = gl_MultiTexCoord2.xyz;\n"
 958 "       VectorR = gl_MultiTexCoord3.xyz;\n"
 959 "#endif\n"
 960 "\n"
 961 "       // transform vertex to camera space, using ftransform to match non-VS rendering\n"
 962 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 963 "\n"
 964 "#ifdef USEREFLECTION\n"
 965 "       ModelViewProjectionPosition = gl_Position;\n"
 966 "#endif\n"
 967 "}\n"
 968 "#endif // !MODE_DEFERREDLIGHTSOURCE\n"
 969 "#endif // !MODE_DEFERREDGEOMETRY\n"
 970 "\n"
 971 "#endif // VERTEX_SHADER\n"
 972 "\n"
 973 "\n"
 974 "\n"
 975 "\n"
 976 "// fragment shader specific:\n"
 977 "#ifdef FRAGMENT_SHADER\n"
 978 "\n"
 979 "uniform sampler2D Texture_Normal;\n"
 980 "uniform sampler2D Texture_Color;\n"
 981 "//#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
 982 "uniform sampler2D Texture_Gloss;\n"
 983 "//#endif\n"
 984 "#ifdef USEGLOW\n"
 985 "uniform sampler2D Texture_Glow;\n"
 986 "#endif\n"
 987 "#ifdef USEVERTEXTEXTUREBLEND\n"
 988 "uniform sampler2D Texture_SecondaryNormal;\n"
 989 "uniform sampler2D Texture_SecondaryColor;\n"
 990 "//#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
 991 "uniform sampler2D Texture_SecondaryGloss;\n"
 992 "//#endif\n"
 993 "#ifdef USEGLOW\n"
 994 "uniform sampler2D Texture_SecondaryGlow;\n"
 995 "#endif\n"
 996 "#endif\n"
 997 "#ifdef USECOLORMAPPING\n"
 998 "uniform sampler2D Texture_Pants;\n"
 999 "uniform sampler2D Texture_Shirt;\n"
1000 "#endif\n"
1001 "#ifdef USEFOG\n"
1002 "uniform sampler2D Texture_FogMask;\n"
1003 "#endif\n"
1004 "#ifdef USELIGHTMAP\n"
1005 "uniform sampler2D Texture_Lightmap;\n"
1006 "#endif\n"
1007 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
1008 "uniform sampler2D Texture_Deluxemap;\n"
1009 "#endif\n"
1010 "#ifdef USEREFLECTION\n"
1011 "uniform sampler2D Texture_Reflection;\n"
1012 "#endif\n"
1013 "\n"
1014 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
1015 "uniform sampler2DRect Texture_ScreenDepth;\n"
1016 "uniform sampler2DRect Texture_ScreenNormalMap;\n"
1017 "#endif\n"
1018 "#ifdef USEDEFERREDLIGHTMAP\n"
1019 "uniform sampler2DRect Texture_ScreenDiffuse;\n"
1020 "uniform sampler2DRect Texture_ScreenSpecular;\n"
1021 "#endif\n"
1022 "\n"
1023 "uniform myhalf3 Color_Pants;\n"
1024 "uniform myhalf3 Color_Shirt;\n"
1025 "uniform myhalf3 FogColor;\n"
1026 "\n"
1027 "#ifdef USEFOG\n"
1028 "uniform float FogRangeRecip;\n"
1029 "uniform float FogPlaneViewDist;\n"
1030 "uniform float FogHeightFade;\n"
1031 "myhalf FogVertex(void)\n"
1032 "{\n"
1033 "       float fogfrac;\n"
1034 "#ifdef USEFOGOUTSIDE\n"
1035 "       fogfrac = min(0.0, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0, min(0.0, FogPlaneVertexDist) * FogHeightFade);\n"
1036 "#else\n"
1037 "       fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0, FogPlaneVertexDist)) * min(1.0, (min(0.0, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);\n"
1038 "#endif\n"
1039 "       return myhalf(texture2D(Texture_FogMask, myhalf2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)));\n"
1040 "}\n"
1041 "#endif\n"
1042 "\n"
1043 "#ifdef USEOFFSETMAPPING\n"
1044 "uniform float OffsetMapping_Scale;\n"
1045 "vec2 OffsetMapping(vec2 TexCoord)\n"
1046 "{\n"
1047 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
1048 "       // 14 sample relief mapping: linear search and then binary search\n"
1049 "       // this basically steps forward a small amount repeatedly until it finds\n"
1050 "       // itself inside solid, then jitters forward and back using decreasing\n"
1051 "       // amounts to find the impact\n"
1052 "       //vec3 OffsetVector = vec3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1), -1);\n"
1053 "       //vec3 OffsetVector = vec3(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
1054 "       vec3 OffsetVector = vec3(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
1055 "       vec3 RT = vec3(TexCoord, 1);\n"
1056 "       OffsetVector *= 0.1;\n"
1057 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1058 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1059 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1060 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1061 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1062 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1063 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1064 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1065 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1066 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z)          - 0.5);\n"
1067 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.5    - 0.25);\n"
1068 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.25   - 0.125);\n"
1069 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.125  - 0.0625);\n"
1070 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
1071 "       return RT.xy;\n"
1072 "#else\n"
1073 "       // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
1074 "       // this basically moves forward the full distance, and then backs up based\n"
1075 "       // on height of samples\n"
1076 "       //vec2 OffsetVector = vec2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1));\n"
1077 "       //vec2 OffsetVector = vec2(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1));\n"
1078 "       vec2 OffsetVector = vec2(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1));\n"
1079 "       TexCoord += OffsetVector;\n"
1080 "       OffsetVector *= 0.333;\n"
1081 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1082 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1083 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1084 "       return TexCoord;\n"
1085 "#endif\n"
1086 "}\n"
1087 "#endif // USEOFFSETMAPPING\n"
1088 "\n"
1089 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n"
1090 "uniform sampler2D Texture_Attenuation;\n"
1091 "uniform samplerCube Texture_Cube;\n"
1092 "\n"
1093 "#ifdef USESHADOWMAPRECT\n"
1094 "# ifdef USESHADOWSAMPLER\n"
1095 "uniform sampler2DRectShadow Texture_ShadowMapRect;\n"
1096 "# else\n"
1097 "uniform sampler2DRect Texture_ShadowMapRect;\n"
1098 "# endif\n"
1099 "#endif\n"
1100 "\n"
1101 "#ifdef USESHADOWMAP2D\n"
1102 "# ifdef USESHADOWSAMPLER\n"
1103 "uniform sampler2DShadow Texture_ShadowMap2D;\n"
1104 "# else\n"
1105 "uniform sampler2D Texture_ShadowMap2D;\n"
1106 "# endif\n"
1107 "#endif\n"
1108 "\n"
1109 "#ifdef USESHADOWMAPVSDCT\n"
1110 "uniform samplerCube Texture_CubeProjection;\n"
1111 "#endif\n"
1112 "\n"
1113 "#ifdef USESHADOWMAPCUBE\n"
1114 "# ifdef USESHADOWSAMPLER\n"
1115 "uniform samplerCubeShadow Texture_ShadowMapCube;\n"
1116 "# else\n"
1117 "uniform samplerCube Texture_ShadowMapCube;\n"
1118 "# endif\n"
1119 "#endif\n"
1120 "\n"
1121 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D) || defined(USESHADOWMAPCUBE)\n"
1122 "uniform vec2 ShadowMap_TextureScale;\n"
1123 "uniform vec4 ShadowMap_Parameters;\n"
1124 "#endif\n"
1125 "\n"
1126 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n"
1127 "vec3 GetShadowMapTC2D(vec3 dir)\n"
1128 "{\n"
1129 "       vec3 adir = abs(dir);\n"
1130 "# ifndef USESHADOWMAPVSDCT\n"
1131 "       vec2 tc;\n"
1132 "       vec2 offset;\n"
1133 "       float ma;\n"
1134 "       if (adir.x > adir.y)\n"
1135 "       {\n"
1136 "               if (adir.x > adir.z) // X\n"
1137 "               {\n"
1138 "                       ma = adir.x;\n"
1139 "                       tc = dir.zy;\n"
1140 "                       offset = vec2(mix(0.5, 1.5, dir.x < 0.0), 0.5);\n"
1141 "               }\n"
1142 "               else // Z\n"
1143 "               {\n"
1144 "                       ma = adir.z;\n"
1145 "                       tc = dir.xy;\n"
1146 "                       offset = vec2(mix(0.5, 1.5, dir.z < 0.0), 2.5);\n"
1147 "               }\n"
1148 "       }\n"
1149 "       else\n"
1150 "       {\n"
1151 "               if (adir.y > adir.z) // Y\n"
1152 "               {\n"
1153 "                       ma = adir.y;\n"
1154 "                       tc = dir.xz;\n"
1155 "                       offset = vec2(mix(0.5, 1.5, dir.y < 0.0), 1.5);\n"
1156 "               }\n"
1157 "               else // Z\n"
1158 "               {\n"
1159 "                       ma = adir.z;\n"
1160 "                       tc = dir.xy;\n"
1161 "                       offset = vec2(mix(0.5, 1.5, dir.z < 0.0), 2.5);\n"
1162 "               }\n"
1163 "       }\n"
1164 "\n"
1165 "       vec3 stc = vec3(tc * ShadowMap_Parameters.x, ShadowMap_Parameters.w) / ma;\n"
1166 "       stc.xy += offset * ShadowMap_Parameters.y;\n"
1167 "       stc.z += ShadowMap_Parameters.z;\n"
1168 "       return stc;\n"
1169 "# else\n"
1170 "       vec4 proj = textureCube(Texture_CubeProjection, dir);\n"
1171 "       float ma = max(max(adir.x, adir.y), adir.z);\n"
1172 "       vec3 stc = vec3(mix(dir.xy, dir.zz, proj.xy) * ShadowMap_Parameters.x, ShadowMap_Parameters.w) / ma;\n"
1173 "       stc.xy += proj.zw * ShadowMap_Parameters.y;\n"
1174 "       stc.z += ShadowMap_Parameters.z;\n"
1175 "       return stc;\n"
1176 "# endif\n"
1177 "}\n"
1178 "#endif // defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n"
1179 "\n"
1180 "#ifdef USESHADOWMAPCUBE\n"
1181 "vec4 GetShadowMapTCCube(vec3 dir)\n"
1182 "{\n"
1183 "    vec3 adir = abs(dir);\n"
1184 "    return vec4(dir, ShadowMap_Parameters.z + ShadowMap_Parameters.w / max(max(adir.x, adir.y), adir.z));\n"
1185 "}\n"
1186 "#endif\n"
1187 "\n"
1188 "# ifdef USESHADOWMAPRECT\n"
1189 "float ShadowMapCompare(vec3 dir)\n"
1190 "{\n"
1191 "       vec3 shadowmaptc = GetShadowMapTC2D(dir);\n"
1192 "       float f;\n"
1193 "#  ifdef USESHADOWSAMPLER\n"
1194 "\n"
1195 "#    ifdef USESHADOWMAPPCF\n"
1196 "#      define texval(x, y) shadow2DRect(Texture_ShadowMapRect, shadowmaptc + vec3(x, y, 0.0)).r\n"
1197 "    f = dot(vec4(0.25), vec4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n"
1198 "#    else\n"
1199 "    f = shadow2DRect(Texture_ShadowMapRect, shadowmaptc).r;\n"
1200 "#    endif\n"
1201 "\n"
1202 "#  else\n"
1203 "\n"
1204 "#    ifdef USESHADOWMAPPCF\n"
1205 "#      if USESHADOWMAPPCF > 1\n"
1206 "#        define texval(x, y) texture2DRect(Texture_ShadowMapRect, center + vec2(x, y)).r\n"
1207 "    vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n"
1208 "    vec4 row1 = step(shadowmaptc.z, vec4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n"
1209 "    vec4 row2 = step(shadowmaptc.z, vec4(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0), texval( 2.0,  0.0)));\n"
1210 "    vec4 row3 = step(shadowmaptc.z, vec4(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0), texval( 2.0,  1.0)));\n"
1211 "    vec4 row4 = step(shadowmaptc.z, vec4(texval(-1.0,  2.0), texval( 0.0,  2.0), texval( 1.0,  2.0), texval( 2.0,  2.0)));\n"
1212 "    vec4 cols = row2 + row3 + mix(row1, row4, offset.y);\n"
1213 "    f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
1214 "#      else\n"
1215 "#        define texval(x, y) texture2DRect(Texture_ShadowMapRect, shadowmaptc.xy + vec2(x, y)).r\n"
1216 "    vec2 offset = fract(shadowmaptc.xy);\n"
1217 "    vec3 row1 = step(shadowmaptc.z, vec3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
1218 "    vec3 row2 = step(shadowmaptc.z, vec3(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0)));\n"
1219 "    vec3 row3 = step(shadowmaptc.z, vec3(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0)));\n"
1220 "    vec3 cols = row2 + mix(row1, row3, offset.y);\n"
1221 "    f = dot(mix(cols.xy, cols.yz, offset.x), vec2(0.25));\n"
1222 "#      endif\n"
1223 "#    else\n"
1224 "    f = step(shadowmaptc.z, texture2DRect(Texture_ShadowMapRect, shadowmaptc.xy).r);\n"
1225 "#    endif\n"
1226 "\n"
1227 "#  endif\n"
1228 "       return f;\n"
1229 "}\n"
1230 "# endif\n"
1231 "\n"
1232 "# ifdef USESHADOWMAP2D\n"
1233 "float ShadowMapCompare(vec3 dir)\n"
1234 "{\n"
1235 "    vec3 shadowmaptc = GetShadowMapTC2D(dir);\n"
1236 "    float f;\n"
1237 "\n"
1238 "#  ifdef USESHADOWSAMPLER\n"
1239 "#    ifdef USESHADOWMAPPCF\n"
1240 "#      define texval(x, y) shadow2D(Texture_ShadowMap2D, vec3(center + vec2(x, y)*ShadowMap_TextureScale, shadowmaptc.z)).r  \n"
1241 "    vec2 center = shadowmaptc.xy*ShadowMap_TextureScale;\n"
1242 "    f = dot(vec4(0.25), vec4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n"
1243 "#    else\n"
1244 "    f = shadow2D(Texture_ShadowMap2D, vec3(shadowmaptc.xy*ShadowMap_TextureScale, shadowmaptc.z)).r;\n"
1245 "#    endif\n"
1246 "#  else\n"
1247 "#    ifdef USESHADOWMAPPCF\n"
1248 "#     if defined(GL_ARB_texture_gather) || defined(GL_AMD_texture_texture4)\n"
1249 "#      ifdef GL_ARB_texture_gather\n"
1250 "#        define texval(x, y) textureGatherOffset(Texture_ShadowMap2D, center, ivec(x, y))\n"
1251 "#      else\n"
1252 "#        define texval(x, y) texture4(Texture_ShadowMap2D, center + vec2(x,y)*ShadowMap_TextureScale)\n"
1253 "#      endif\n"
1254 "    vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n"
1255 "    center *= ShadowMap_TextureScale;\n"
1256 "    vec4 group1 = step(shadowmaptc.z, texval(-1.0, -1.0));\n"
1257 "    vec4 group2 = step(shadowmaptc.z, texval( 1.0, -1.0));\n"
1258 "    vec4 group3 = step(shadowmaptc.z, texval(-1.0,  1.0));\n"
1259 "    vec4 group4 = step(shadowmaptc.z, texval( 1.0,  1.0));\n"
1260 "    vec4 cols = vec4(group1.rg, group2.rg) + vec4(group3.ab, group4.ab) +\n"
1261 "                mix(vec4(group1.ab, group2.ab), vec4(group3.rg, group4.rg), offset.y);\n"
1262 "    f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
1263 "#     else\n"
1264 "#      ifdef GL_EXT_gpu_shader4\n"
1265 "#        define texval(x, y) texture2DOffset(Texture_ShadowMap2D, center, ivec2(x, y)).r\n"
1266 "#      else\n"
1267 "#        define texval(x, y) texture2D(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale).r  \n"
1268 "#      endif\n"
1269 "#      if USESHADOWMAPPCF > 1\n"
1270 "    vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n"
1271 "    center *= ShadowMap_TextureScale;\n"
1272 "    vec4 row1 = step(shadowmaptc.z, vec4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n"
1273 "    vec4 row2 = step(shadowmaptc.z, vec4(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0), texval( 2.0,  0.0)));\n"
1274 "    vec4 row3 = step(shadowmaptc.z, vec4(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0), texval( 2.0,  1.0)));\n"
1275 "    vec4 row4 = step(shadowmaptc.z, vec4(texval(-1.0,  2.0), texval( 0.0,  2.0), texval( 1.0,  2.0), texval( 2.0,  2.0)));\n"
1276 "    vec4 cols = row2 + row3 + mix(row1, row4, offset.y);\n"
1277 "    f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
1278 "#      else\n"
1279 "    vec2 center = shadowmaptc.xy*ShadowMap_TextureScale, offset = fract(shadowmaptc.xy);\n"
1280 "    vec3 row1 = step(shadowmaptc.z, vec3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
1281 "    vec3 row2 = step(shadowmaptc.z, vec3(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0)));\n"
1282 "    vec3 row3 = step(shadowmaptc.z, vec3(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0)));\n"
1283 "    vec3 cols = row2 + mix(row1, row3, offset.y);\n"
1284 "    f = dot(mix(cols.xy, cols.yz, offset.x), vec2(0.25));\n"
1285 "#      endif\n"
1286 "#     endif\n"
1287 "#    else\n"
1288 "    f = step(shadowmaptc.z, texture2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale).r);\n"
1289 "#    endif\n"
1290 "#  endif\n"
1291 "    return f;\n"
1292 "}\n"
1293 "# endif\n"
1294 "\n"
1295 "# ifdef USESHADOWMAPCUBE\n"
1296 "float ShadowMapCompare(vec3 dir)\n"
1297 "{\n"
1298 "    // apply depth texture cubemap as light filter\n"
1299 "    vec4 shadowmaptc = GetShadowMapTCCube(dir);\n"
1300 "    float f;\n"
1301 "#  ifdef USESHADOWSAMPLER\n"
1302 "    f = shadowCube(Texture_ShadowMapCube, shadowmaptc).r;\n"
1303 "#  else\n"
1304 "    f = step(shadowmaptc.w, textureCube(Texture_ShadowMapCube, shadowmaptc.xyz).r);\n"
1305 "#  endif\n"
1306 "    return f;\n"
1307 "}\n"
1308 "# endif\n"
1309 "#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE)\n"
1310 "\n"
1311 "#ifdef MODE_DEFERREDGEOMETRY\n"
1312 "void main(void)\n"
1313 "{\n"
1314 "#ifdef USEOFFSETMAPPING\n"
1315 "       // apply offsetmapping\n"
1316 "       vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
1317 "#define TexCoord TexCoordOffset\n"
1318 "#endif\n"
1319 "\n"
1320 "#ifdef USEALPHAKILL\n"
1321 "       if (texture2D(Texture_Color, TexCoord).a < 0.5)\n"
1322 "               discard;\n"
1323 "#endif\n"
1324 "\n"
1325 "#ifdef USEVERTEXTEXTUREBLEND\n"
1326 "       float alpha = texture2D(Texture_Color, TexCoord).a;\n"
1327 "       float terrainblend = clamp(float(gl_Color.a) * alpha * 2.0 - 0.5, float(0.0), float(1.0));\n"
1328 "       //float terrainblend = min(float(gl_Color.a) * alpha * 2.0, float(1.0));\n"
1329 "       //float terrainblend = float(gl_Color.a) * alpha > 0.5;\n"
1330 "#endif\n"
1331 "\n"
1332 "#ifdef USEVERTEXTEXTUREBLEND\n"
1333 "       vec3 surfacenormal = mix(vec3(texture2D(Texture_SecondaryNormal, TexCoord2)), vec3(texture2D(Texture_Normal, TexCoord)), terrainblend) - vec3(0.5, 0.5, 0.5);\n"
1334 "#else\n"
1335 "       vec3 surfacenormal = vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5, 0.5, 0.5);\n"
1336 "#endif\n"
1337 "\n"
1338 "       gl_FragColor = vec4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR) * 0.5 + vec3(0.5, 0.5, 0.5), 1);\n"
1339 "}\n"
1340 "#else // !MODE_DEFERREDGEOMETRY\n"
1341 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
1342 "uniform mat4 ViewToLight;\n"
1343 "// ScreenToDepth = vec2(Far / (Far - Near), Far * Near / (Near - Far));\n"
1344 "uniform vec2 ScreenToDepth;\n"
1345 "uniform myhalf3 DeferredColor_Ambient;\n"
1346 "uniform myhalf3 DeferredColor_Diffuse;\n"
1347 "#ifdef USESPECULAR\n"
1348 "uniform myhalf3 DeferredColor_Specular;\n"
1349 "uniform myhalf SpecularPower;\n"
1350 "#endif\n"
1351 "void main(void)\n"
1352 "{\n"
1353 "       // calculate viewspace pixel position\n"
1354 "       vec3 position;\n"
1355 "       position.z = ScreenToDepth.y / (texture2DRect(Texture_ScreenDepth, gl_FragCoord.xy).r + ScreenToDepth.x);\n"
1356 "       position.xy = ModelViewPosition.xy * (position.z / ModelViewPosition.z);\n"
1357 "       // decode viewspace pixel normal\n"
1358 "       myhalf4 normalmap = texture2DRect(Texture_ScreenNormalMap, gl_FragCoord.xy);\n"
1359 "       myhalf3 surfacenormal = normalize(normalmap.rgb - myhalf3(0.5,0.5,0.5));\n"
1360 "       // surfacenormal = pixel normal in viewspace\n"
1361 "       // LightVector = pixel to light in viewspace\n"
1362 "       // CubeVector = position in lightspace\n"
1363 "       // eyevector = pixel to view in viewspace\n"
1364 "       vec3 CubeVector = vec3(ViewToLight * vec4(position,1));\n"
1365 "       myhalf fade = myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
1366 "#ifdef USEDIFFUSE\n"
1367 "       // calculate diffuse shading\n"
1368 "       myhalf3 lightnormal = myhalf3(normalize(LightPosition - position));\n"
1369 "       myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1370 "#endif\n"
1371 "#ifdef USESPECULAR\n"
1372 "       // calculate directional shading\n"
1373 "       vec3 eyevector = position * -1.0;\n"
1374 "#  ifdef USEEXACTSPECULARMATH\n"
1375 "       myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower);\n"
1376 "#  else\n"
1377 "       myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(eyevector)));\n"
1378 "       myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
1379 "#  endif\n"
1380 "#endif\n"
1381 "\n"
1382 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAPCUBE) || defined(USESHADOWMAP2D)\n"
1383 "       fade *= ShadowMapCompare(CubeVector);\n"
1384 "#endif\n"
1385 "\n"
1386 "#ifdef USEDIFFUSE\n"
1387 "       gl_FragData[0] = vec4((DeferredColor_Ambient + DeferredColor_Diffuse * diffuse) * fade, 1.0);\n"
1388 "#else\n"
1389 "       gl_FragData[0] = vec4(DeferredColor_Ambient * fade, 1.0);\n"
1390 "#endif\n"
1391 "#ifdef USESPECULAR\n"
1392 "       gl_FragData[1] = vec4(DeferredColor_Specular * (specular * fade), 1.0);\n"
1393 "#else\n"
1394 "       gl_FragData[1] = vec4(0.0, 0.0, 0.0, 1.0);\n"
1395 "#endif\n"
1396 "\n"
1397 "# ifdef USECUBEFILTER\n"
1398 "       vec3 cubecolor = textureCube(Texture_Cube, CubeVector).rgb;\n"
1399 "       gl_FragData[0] *= cubecolor;\n"
1400 "       gl_FragData[1] *= cubecolor;\n"
1401 "# endif\n"
1402 "}\n"
1403 "#else // !MODE_DEFERREDLIGHTSOURCE\n"
1404 "#ifdef USEDEFERREDLIGHTMAP\n"
1405 "uniform myhalf3 DeferredMod_Diffuse;\n"
1406 "uniform myhalf3 DeferredMod_Specular;\n"
1407 "#endif\n"
1408 "uniform myhalf3 Color_Ambient;\n"
1409 "uniform myhalf3 Color_Diffuse;\n"
1410 "uniform myhalf3 Color_Specular;\n"
1411 "uniform myhalf SpecularPower;\n"
1412 "#ifdef USEGLOW\n"
1413 "uniform myhalf3 Color_Glow;\n"
1414 "#endif\n"
1415 "uniform myhalf Alpha;\n"
1416 "#ifdef USEREFLECTION\n"
1417 "uniform vec4 DistortScaleRefractReflect;\n"
1418 "uniform vec4 ScreenScaleRefractReflect;\n"
1419 "uniform vec4 ScreenCenterRefractReflect;\n"
1420 "uniform myhalf4 ReflectColor;\n"
1421 "#endif\n"
1422 "#ifdef MODE_LIGHTDIRECTION\n"
1423 "uniform myhalf3 LightColor;\n"
1424 "#endif\n"
1425 "#ifdef MODE_LIGHTSOURCE\n"
1426 "uniform myhalf3 LightColor;\n"
1427 "#endif\n"
1428 "void main(void)\n"
1429 "{\n"
1430 "#ifdef USEOFFSETMAPPING\n"
1431 "       // apply offsetmapping\n"
1432 "       vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
1433 "#define TexCoord TexCoordOffset\n"
1434 "#endif\n"
1435 "\n"
1436 "       // combine the diffuse textures (base, pants, shirt)\n"
1437 "       myhalf4 color = myhalf4(texture2D(Texture_Color, TexCoord));\n"
1438 "#ifdef USEALPHAKILL\n"
1439 "       if (color.a < 0.5)\n"
1440 "               discard;\n"
1441 "#endif\n"
1442 "       color.a *= Alpha;\n"
1443 "#ifdef USECOLORMAPPING\n"
1444 "       color.rgb += myhalf3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + myhalf3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
1445 "#endif\n"
1446 "#ifdef USEVERTEXTEXTUREBLEND\n"
1447 "       myhalf terrainblend = clamp(myhalf(gl_Color.a) * color.a * 2.0 - 0.5, myhalf(0.0), myhalf(1.0));\n"
1448 "       //myhalf terrainblend = min(myhalf(gl_Color.a) * color.a * 2.0, myhalf(1.0));\n"
1449 "       //myhalf terrainblend = myhalf(gl_Color.a) * color.a > 0.5;\n"
1450 "       color.rgb = mix(myhalf3(texture2D(Texture_SecondaryColor, TexCoord2)), color.rgb, terrainblend);\n"
1451 "       color.a = 1.0;\n"
1452 "       //color = mix(myhalf4(1, 0, 0, 1), color, terrainblend);\n"
1453 "#endif\n"
1454 "\n"
1455 "       // get the surface normal\n"
1456 "#ifdef USEVERTEXTEXTUREBLEND\n"
1457 "       myhalf3 surfacenormal = normalize(mix(myhalf3(texture2D(Texture_SecondaryNormal, TexCoord2)), myhalf3(texture2D(Texture_Normal, TexCoord)), terrainblend) - myhalf3(0.5, 0.5, 0.5));\n"
1458 "#else\n"
1459 "       myhalf3 surfacenormal = normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5, 0.5, 0.5));\n"
1460 "#endif\n"
1461 "\n"
1462 "       // get the material colors\n"
1463 "       myhalf3 diffusetex = color.rgb;\n"
1464 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
1465 "# ifdef USEVERTEXTEXTUREBLEND\n"
1466 "       myhalf3 glosstex = mix(myhalf3(texture2D(Texture_SecondaryGloss, TexCoord2)), myhalf3(texture2D(Texture_Gloss, TexCoord)), terrainblend);\n"
1467 "# else\n"
1468 "       myhalf3 glosstex = myhalf3(texture2D(Texture_Gloss, TexCoord));\n"
1469 "# endif\n"
1470 "#endif\n"
1471 "\n"
1472 "\n"
1473 "\n"
1474 "\n"
1475 "#ifdef MODE_LIGHTSOURCE\n"
1476 "       // light source\n"
1477 "       myhalf3 lightnormal = myhalf3(normalize(LightVector));\n"
1478 "       myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1479 "       color.rgb = diffusetex * (Color_Ambient + diffuse * Color_Diffuse);\n"
1480 "#ifdef USESPECULAR\n"
1481 "#ifdef USEEXACTSPECULARMATH\n"
1482 "       myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower);\n"
1483 "#else\n"
1484 "       myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(EyeVector)));\n"
1485 "       myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
1486 "#endif\n"
1487 "       color.rgb += glosstex * (specular * Color_Specular);\n"
1488 "#endif\n"
1489 "       color.rgb *= LightColor;\n"
1490 "       color.rgb *= myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
1491 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAPCUBE) || defined(USESHADOWMAP2D)\n"
1492 "       color.rgb *= ShadowMapCompare(CubeVector);\n"
1493 "#endif\n"
1494 "# ifdef USECUBEFILTER\n"
1495 "       color.rgb *= myhalf3(textureCube(Texture_Cube, CubeVector));\n"
1496 "# endif\n"
1497 "#endif // MODE_LIGHTSOURCE\n"
1498 "\n"
1499 "\n"
1500 "\n"
1501 "\n"
1502 "#ifdef MODE_LIGHTDIRECTION\n"
1503 "#define SHADING\n"
1504 "       myhalf3 lightnormal = myhalf3(normalize(LightVector));\n"
1505 "#define lightcolor LightColor\n"
1506 "#endif // MODE_LIGHTDIRECTION\n"
1507 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
1508 "#define SHADING\n"
1509 "       // deluxemap lightmapping using light vectors in modelspace (q3map2 -light -deluxe)\n"
1510 "       myhalf3 lightnormal_modelspace = myhalf3(texture2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + myhalf3(-1.0, -1.0, -1.0);\n"
1511 "       myhalf3 lightcolor = myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap));\n"
1512 "       // convert modelspace light vector to tangentspace\n"
1513 "       myhalf3 lightnormal;\n"
1514 "       lightnormal.x = dot(lightnormal_modelspace, myhalf3(VectorS));\n"
1515 "       lightnormal.y = dot(lightnormal_modelspace, myhalf3(VectorT));\n"
1516 "       lightnormal.z = dot(lightnormal_modelspace, myhalf3(VectorR));\n"
1517 "       // calculate directional shading (and undoing the existing angle attenuation on the lightmap by the division)\n"
1518 "       // note that q3map2 is too stupid to calculate proper surface normals when q3map_nonplanar\n"
1519 "       // is used (the lightmap and deluxemap coords correspond to virtually random coordinates\n"
1520 "       // on that luxel, and NOT to its center, because recursive triangle subdivision is used\n"
1521 "       // to map the luxels to coordinates on the draw surfaces), which also causes\n"
1522 "       // deluxemaps to be wrong because light contributions from the wrong side of the surface\n"
1523 "       // are added up. To prevent divisions by zero or strong exaggerations, a max()\n"
1524 "       // nudge is done here at expense of some additional fps. This is ONLY needed for\n"
1525 "       // deluxemaps, tangentspace deluxemap avoid this problem by design.\n"
1526 "       lightcolor *= 1.0 / max(0.25, lightnormal.z);\n"
1527 "#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
1528 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
1529 "#define SHADING\n"
1530 "       // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
1531 "       myhalf3 lightnormal = myhalf3(texture2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + myhalf3(-1.0, -1.0, -1.0);\n"
1532 "       myhalf3 lightcolor = myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap));\n"
1533 "#endif\n"
1534 "\n"
1535 "\n"
1536 "\n"
1537 "\n"
1538 "#ifdef MODE_LIGHTMAP\n"
1539 "       color.rgb = diffusetex * (Color_Ambient + myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap)) * Color_Diffuse);\n"
1540 "#endif // MODE_LIGHTMAP\n"
1541 "#ifdef MODE_VERTEXCOLOR\n"
1542 "       color.rgb = diffusetex * (Color_Ambient + myhalf3(gl_Color.rgb) * Color_Diffuse);\n"
1543 "#endif // MODE_VERTEXCOLOR\n"
1544 "#ifdef MODE_FLATCOLOR\n"
1545 "       color.rgb = diffusetex * Color_Ambient;\n"
1546 "#endif // MODE_FLATCOLOR\n"
1547 "\n"
1548 "\n"
1549 "\n"
1550 "\n"
1551 "#ifdef SHADING\n"
1552 "# ifdef USEDIFFUSE\n"
1553 "       myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1554 "#  ifdef USESPECULAR\n"
1555 "#   ifdef USEEXACTSPECULARMATH\n"
1556 "       myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower);\n"
1557 "#   else\n"
1558 "       myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(EyeVector)));\n"
1559 "       myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
1560 "#   endif\n"
1561 "       color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex * Color_Specular * specular) * lightcolor;\n"
1562 "#  else\n"
1563 "       color.rgb = diffusetex * (Color_Ambient + Color_Diffuse * diffuse * lightcolor);\n"
1564 "#  endif\n"
1565 "# else\n"
1566 "       color.rgb = diffusetex * Color_Ambient;\n"
1567 "# endif\n"
1568 "#endif\n"
1569 "\n"
1570 "#ifdef USEDEFERREDLIGHTMAP\n"
1571 "       color.rgb += diffusetex * myhalf3(texture2DRect(Texture_ScreenDiffuse, gl_FragCoord.xy)) * DeferredMod_Diffuse;\n"
1572 "       color.rgb += glosstex * myhalf3(texture2DRect(Texture_ScreenSpecular, gl_FragCoord.xy)) * DeferredMod_Specular;\n"
1573 "#endif\n"
1574 "\n"
1575 "#ifdef USEGLOW\n"
1576 "#ifdef USEVERTEXTEXTUREBLEND\n"
1577 "       color.rgb += mix(myhalf3(texture2D(Texture_SecondaryGlow, TexCoord2)), myhalf3(texture2D(Texture_Glow, TexCoord)), terrainblend) * Color_Glow;\n"
1578 "#else\n"
1579 "       color.rgb += myhalf3(texture2D(Texture_Glow, TexCoord)) * Color_Glow;\n"
1580 "#endif\n"
1581 "#endif\n"
1582 "\n"
1583 "#ifdef USEFOG\n"
1584 "       color.rgb = mix(FogColor, color.rgb, FogVertex());\n"
1585 "#endif\n"
1586 "\n"
1587 "       // 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"
1588 "#ifdef USEREFLECTION\n"
1589 "       vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
1590 "       //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
1591 "       vec2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW.zw + ScreenCenterRefractReflect.zw;\n"
1592 "       vec2 ScreenTexCoord = SafeScreenTexCoord + vec3(normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5))).xy * DistortScaleRefractReflect.zw;\n"
1593 "       // FIXME temporary hack to detect the case that the reflection\n"
1594 "       // gets blackened at edges due to leaving the area that contains actual\n"
1595 "       // content.\n"
1596 "       // Remove this 'ack once we have a better way to stop this thing from\n"
1597 "       // 'appening.\n"
1598 "       float f = min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(0.01, 0.01)).rgb) / 0.05);\n"
1599 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(0.01, -0.01)).rgb) / 0.05);\n"
1600 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
1601 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
1602 "       ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n"
1603 "       color.rgb = mix(color.rgb, myhalf3(texture2D(Texture_Reflection, ScreenTexCoord)) * ReflectColor.rgb, ReflectColor.a);\n"
1604 "#endif\n"
1605 "\n"
1606 "       gl_FragColor = vec4(color);\n"
1607 "}\n"
1608 "#endif // !MODE_DEFERREDLIGHTSOURCE\n"
1609 "#endif // !MODE_DEFERREDGEOMETRY\n"
1610 "\n"
1611 "#endif // FRAGMENT_SHADER\n"
1612 "\n"
1613 "#endif // !MODE_WATER\n"
1614 "#endif // !MODE_REFRACTION\n"
1615 "#endif // !MODE_BLOOMBLUR\n"
1616 "#endif // !MODE_GENERIC\n"
1617 "#endif // !MODE_POSTPROCESS\n"
1618 "#endif // !MODE_SHOWDEPTH\n"
1619 "#endif // !MODE_DEPTH_OR_SHADOW\n"
1620 ;
1621
1622 const char *builtincgshaderstring = "";
1623
1624 typedef struct shaderpermutationinfo_s
1625 {
1626         const char *pretext;
1627         const char *name;
1628 }
1629 shaderpermutationinfo_t;
1630
1631 typedef struct shadermodeinfo_s
1632 {
1633         const char *vertexfilename;
1634         const char *geometryfilename;
1635         const char *fragmentfilename;
1636         const char *pretext;
1637         const char *name;
1638 }
1639 shadermodeinfo_t;
1640
1641 typedef enum shaderpermutation_e
1642 {
1643         SHADERPERMUTATION_DIFFUSE = 1<<0, ///< (lightsource) whether to use directional shading
1644         SHADERPERMUTATION_VERTEXTEXTUREBLEND = 1<<1, ///< indicates this is a two-layer material blend based on vertex alpha (q3bsp)
1645         SHADERPERMUTATION_VIEWTINT = 1<<2, ///< view tint (postprocessing only)
1646         SHADERPERMUTATION_COLORMAPPING = 1<<3, ///< indicates this is a colormapped skin
1647         SHADERPERMUTATION_SATURATION = 1<<4, ///< saturation (postprocessing only)
1648         SHADERPERMUTATION_FOGINSIDE = 1<<5, ///< tint the color by fog color or black if using additive blend mode
1649         SHADERPERMUTATION_FOGOUTSIDE = 1<<6, ///< tint the color by fog color or black if using additive blend mode
1650         SHADERPERMUTATION_GAMMARAMPS = 1<<7, ///< gamma (postprocessing only)
1651         SHADERPERMUTATION_CUBEFILTER = 1<<8, ///< (lightsource) use cubemap light filter
1652         SHADERPERMUTATION_GLOW = 1<<9, ///< (lightmap) blend in an additive glow texture
1653         SHADERPERMUTATION_BLOOM = 1<<10, ///< bloom (postprocessing only)
1654         SHADERPERMUTATION_SPECULAR = 1<<11, ///< (lightsource or deluxemapping) render specular effects
1655         SHADERPERMUTATION_POSTPROCESSING = 1<<12, ///< user defined postprocessing (postprocessing only)
1656         SHADERPERMUTATION_EXACTSPECULARMATH = 1<<13, ///< (lightsource or deluxemapping) use exact reflection map for specular effects, as opposed to the usual OpenGL approximation
1657         SHADERPERMUTATION_REFLECTION = 1<<14, ///< normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface
1658         SHADERPERMUTATION_OFFSETMAPPING = 1<<15, ///< adjust texcoords to roughly simulate a displacement mapped surface
1659         SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING = 1<<16, ///< adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!)
1660         SHADERPERMUTATION_SHADOWMAPRECT = 1<<17, ///< (lightsource) use shadowmap rectangle texture as light filter
1661         SHADERPERMUTATION_SHADOWMAPCUBE = 1<<18, ///< (lightsource) use shadowmap cubemap texture as light filter
1662         SHADERPERMUTATION_SHADOWMAP2D = 1<<19, ///< (lightsource) use shadowmap rectangle texture as light filter
1663         SHADERPERMUTATION_SHADOWMAPPCF = 1<<20, ///< (lightsource) use percentage closer filtering on shadowmap test results
1664         SHADERPERMUTATION_SHADOWMAPPCF2 = 1<<21, ///< (lightsource) use higher quality percentage closer filtering on shadowmap test results
1665         SHADERPERMUTATION_SHADOWSAMPLER = 1<<22, ///< (lightsource) use hardware shadowmap test
1666         SHADERPERMUTATION_SHADOWMAPVSDCT = 1<<23, ///< (lightsource) use virtual shadow depth cube texture for shadowmap indexing
1667         SHADERPERMUTATION_DEFERREDLIGHTMAP = 1<<24, ///< (lightmap) read Texture_ScreenDiffuse/Specular textures and add them on top of lightmapping
1668         SHADERPERMUTATION_ALPHAKILL = 1<<25, ///< (deferredgeometry) discard pixel if diffuse texture alpha below 0.5
1669         SHADERPERMUTATION_LIMIT = 1<<26, ///< size of permutations array
1670         SHADERPERMUTATION_COUNT = 27 ///< size of shaderpermutationinfo array
1671 }
1672 shaderpermutation_t;
1673
1674 // NOTE: MUST MATCH ORDER OF SHADERPERMUTATION_* DEFINES!
1675 shaderpermutationinfo_t shaderpermutationinfo[SHADERPERMUTATION_COUNT] =
1676 {
1677         {"#define USEDIFFUSE\n", " diffuse"},
1678         {"#define USEVERTEXTEXTUREBLEND\n", " vertextextureblend"},
1679         {"#define USEVIEWTINT\n", " viewtint"},
1680         {"#define USECOLORMAPPING\n", " colormapping"},
1681         {"#define USESATURATION\n", " saturation"},
1682         {"#define USEFOGINSIDE\n", " foginside"},
1683         {"#define USEFOGOUTSIDE\n", " fogoutside"},
1684         {"#define USEGAMMARAMPS\n", " gammaramps"},
1685         {"#define USECUBEFILTER\n", " cubefilter"},
1686         {"#define USEGLOW\n", " glow"},
1687         {"#define USEBLOOM\n", " bloom"},
1688         {"#define USESPECULAR\n", " specular"},
1689         {"#define USEPOSTPROCESSING\n", " postprocessing"},
1690         {"#define USEEXACTSPECULARMATH\n", " exactspecularmath"},
1691         {"#define USEREFLECTION\n", " reflection"},
1692         {"#define USEOFFSETMAPPING\n", " offsetmapping"},
1693         {"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"},
1694         {"#define USESHADOWMAPRECT\n", " shadowmaprect"},
1695         {"#define USESHADOWMAPCUBE\n", " shadowmapcube"},
1696         {"#define USESHADOWMAP2D\n", " shadowmap2d"},
1697         {"#define USESHADOWMAPPCF 1\n", " shadowmappcf"},
1698         {"#define USESHADOWMAPPCF 2\n", " shadowmappcf2"},
1699         {"#define USESHADOWSAMPLER\n", " shadowsampler"},
1700         {"#define USESHADOWMAPVSDCT\n", " shadowmapvsdct"},
1701         {"#define USEDEFERREDLIGHTMAP\n", " deferredlightmap"},
1702         {"#define USEALPHAKILL\n", " alphakill"},
1703 };
1704
1705 /// this enum is multiplied by SHADERPERMUTATION_MODEBASE
1706 typedef enum shadermode_e
1707 {
1708         SHADERMODE_GENERIC, ///< (particles/HUD/etc) vertex color, optionally multiplied by one texture
1709         SHADERMODE_POSTPROCESS, ///< postprocessing shader (r_glsl_postprocess)
1710         SHADERMODE_DEPTH_OR_SHADOW, ///< (depthfirst/shadows) vertex shader only
1711         SHADERMODE_FLATCOLOR, ///< (lightmap) modulate texture by uniform color (q1bsp, q3bsp)
1712         SHADERMODE_VERTEXCOLOR, ///< (lightmap) modulate texture by vertex colors (q3bsp)
1713         SHADERMODE_LIGHTMAP, ///< (lightmap) modulate texture by lightmap texture (q1bsp, q3bsp)
1714         SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE, ///< (lightmap) use directional pixel shading from texture containing modelspace light directions (q3bsp deluxemap)
1715         SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE, ///< (lightmap) use directional pixel shading from texture containing tangentspace light directions (q1bsp deluxemap)
1716         SHADERMODE_LIGHTDIRECTION, ///< (lightmap) use directional pixel shading from fixed light direction (q3bsp)
1717         SHADERMODE_LIGHTSOURCE, ///< (lightsource) use directional pixel shading from light source (rtlight)
1718         SHADERMODE_REFRACTION, ///< refract background (the material is rendered normally after this pass)
1719         SHADERMODE_WATER, ///< refract background and reflection (the material is rendered normally after this pass)
1720         SHADERMODE_SHOWDEPTH, ///< (debugging) renders depth as color
1721         SHADERMODE_DEFERREDGEOMETRY, ///< (deferred) render material properties to screenspace geometry buffers
1722         SHADERMODE_DEFERREDLIGHTSOURCE, ///< (deferred) use directional pixel shading from light source (rtlight) on screenspace geometry buffers
1723         SHADERMODE_COUNT
1724 }
1725 shadermode_t;
1726
1727 // NOTE: MUST MATCH ORDER OF SHADERMODE_* ENUMS!
1728 shadermodeinfo_t glslshadermodeinfo[SHADERMODE_COUNT] =
1729 {
1730         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_GENERIC\n", " generic"},
1731         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_POSTPROCESS\n", " postprocess"},
1732         {"glsl/default.glsl", NULL, NULL               , "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"},
1733         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_FLATCOLOR\n", " flatcolor"},
1734         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
1735         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTMAP\n", " lightmap"},
1736         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
1737         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
1738         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
1739         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTSOURCE\n", " lightsource"},
1740         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_REFRACTION\n", " refraction"},
1741         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_WATER\n", " water"},
1742         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_SHOWDEPTH\n", " showdepth"},
1743         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
1744         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
1745 };
1746
1747 #ifdef SUPPORTCG
1748 shadermodeinfo_t cgshadermodeinfo[SHADERMODE_COUNT] =
1749 {
1750         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_GENERIC\n", " generic"},
1751         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_POSTPROCESS\n", " postprocess"},
1752         {"cg/default.cg", NULL, NULL           , "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"},
1753         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_FLATCOLOR\n", " flatcolor"},
1754         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
1755         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTMAP\n", " lightmap"},
1756         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
1757         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
1758         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
1759         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTSOURCE\n", " lightsource"},
1760         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_REFRACTION\n", " refraction"},
1761         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_WATER\n", " water"},
1762         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_SHOWDEPTH\n", " showdepth"},
1763         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
1764         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
1765 };
1766 #endif
1767
1768 struct r_glsl_permutation_s;
1769 typedef struct r_glsl_permutation_s
1770 {
1771         /// hash lookup data
1772         struct r_glsl_permutation_s *hashnext;
1773         unsigned int mode;
1774         unsigned int permutation;
1775
1776         /// indicates if we have tried compiling this permutation already
1777         qboolean compiled;
1778         /// 0 if compilation failed
1779         int program;
1780         /// locations of detected uniforms in program object, or -1 if not found
1781         int loc_Texture_First;
1782         int loc_Texture_Second;
1783         int loc_Texture_GammaRamps;
1784         int loc_Texture_Normal;
1785         int loc_Texture_Color;
1786         int loc_Texture_Gloss;
1787         int loc_Texture_Glow;
1788         int loc_Texture_SecondaryNormal;
1789         int loc_Texture_SecondaryColor;
1790         int loc_Texture_SecondaryGloss;
1791         int loc_Texture_SecondaryGlow;
1792         int loc_Texture_Pants;
1793         int loc_Texture_Shirt;
1794         int loc_Texture_FogMask;
1795         int loc_Texture_Lightmap;
1796         int loc_Texture_Deluxemap;
1797         int loc_Texture_Attenuation;
1798         int loc_Texture_Cube;
1799         int loc_Texture_Refraction;
1800         int loc_Texture_Reflection;
1801         int loc_Texture_ShadowMapRect;
1802         int loc_Texture_ShadowMapCube;
1803         int loc_Texture_ShadowMap2D;
1804         int loc_Texture_CubeProjection;
1805         int loc_Texture_ScreenDepth;
1806         int loc_Texture_ScreenNormalMap;
1807         int loc_Texture_ScreenDiffuse;
1808         int loc_Texture_ScreenSpecular;
1809         int loc_Alpha;
1810         int loc_BloomBlur_Parameters;
1811         int loc_ClientTime;
1812         int loc_Color_Ambient;
1813         int loc_Color_Diffuse;
1814         int loc_Color_Specular;
1815         int loc_Color_Glow;
1816         int loc_Color_Pants;
1817         int loc_Color_Shirt;
1818         int loc_DeferredColor_Ambient;
1819         int loc_DeferredColor_Diffuse;
1820         int loc_DeferredColor_Specular;
1821         int loc_DeferredMod_Diffuse;
1822         int loc_DeferredMod_Specular;
1823         int loc_DistortScaleRefractReflect;
1824         int loc_EyePosition;
1825         int loc_FogColor;
1826         int loc_FogHeightFade;
1827         int loc_FogPlane;
1828         int loc_FogPlaneViewDist;
1829         int loc_FogRangeRecip;
1830         int loc_LightColor;
1831         int loc_LightDir;
1832         int loc_LightPosition;
1833         int loc_OffsetMapping_Scale;
1834         int loc_PixelSize;
1835         int loc_ReflectColor;
1836         int loc_ReflectFactor;
1837         int loc_ReflectOffset;
1838         int loc_RefractColor;
1839         int loc_Saturation;
1840         int loc_ScreenCenterRefractReflect;
1841         int loc_ScreenScaleRefractReflect;
1842         int loc_ScreenToDepth;
1843         int loc_ShadowMap_Parameters;
1844         int loc_ShadowMap_TextureScale;
1845         int loc_SpecularPower;
1846         int loc_UserVec1;
1847         int loc_UserVec2;
1848         int loc_UserVec3;
1849         int loc_UserVec4;
1850         int loc_ViewTintColor;
1851         int loc_ViewToLight;
1852         int loc_ModelToLight;
1853         int loc_TexMatrix;
1854         int loc_BackgroundTexMatrix;
1855         int loc_ModelViewProjectionMatrix;
1856         int loc_ModelViewMatrix;
1857 }
1858 r_glsl_permutation_t;
1859
1860 #define SHADERPERMUTATION_HASHSIZE 256
1861
1862 /// information about each possible shader permutation
1863 r_glsl_permutation_t *r_glsl_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
1864 /// currently selected permutation
1865 r_glsl_permutation_t *r_glsl_permutation;
1866 /// storage for permutations linked in the hash table
1867 memexpandablearray_t r_glsl_permutationarray;
1868
1869 static r_glsl_permutation_t *R_GLSL_FindPermutation(unsigned int mode, unsigned int permutation)
1870 {
1871         //unsigned int hashdepth = 0;
1872         unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
1873         r_glsl_permutation_t *p;
1874         for (p = r_glsl_permutationhash[mode][hashindex];p;p = p->hashnext)
1875         {
1876                 if (p->mode == mode && p->permutation == permutation)
1877                 {
1878                         //if (hashdepth > 10)
1879                         //      Con_Printf("R_GLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
1880                         return p;
1881                 }
1882                 //hashdepth++;
1883         }
1884         p = (r_glsl_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_glsl_permutationarray);
1885         p->mode = mode;
1886         p->permutation = permutation;
1887         p->hashnext = r_glsl_permutationhash[mode][hashindex];
1888         r_glsl_permutationhash[mode][hashindex] = p;
1889         //if (hashdepth > 10)
1890         //      Con_Printf("R_GLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
1891         return p;
1892 }
1893
1894 static char *R_GLSL_GetText(const char *filename, qboolean printfromdisknotice)
1895 {
1896         char *shaderstring;
1897         if (!filename || !filename[0])
1898                 return NULL;
1899         shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
1900         if (shaderstring)
1901         {
1902                 if (printfromdisknotice)
1903                         Con_DPrintf("from disk %s... ", filename);
1904                 return shaderstring;
1905         }
1906         else if (!strcmp(filename, "glsl/default.glsl"))
1907         {
1908                 shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(builtinshaderstring) + 1);
1909                 memcpy(shaderstring, builtinshaderstring, strlen(builtinshaderstring) + 1);
1910         }
1911         return shaderstring;
1912 }
1913
1914 static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode, unsigned int permutation)
1915 {
1916         int i;
1917         shadermodeinfo_t *modeinfo = glslshadermodeinfo + mode;
1918         int vertstrings_count = 0;
1919         int geomstrings_count = 0;
1920         int fragstrings_count = 0;
1921         char *vertexstring, *geometrystring, *fragmentstring;
1922         const char *vertstrings_list[32+3];
1923         const char *geomstrings_list[32+3];
1924         const char *fragstrings_list[32+3];
1925         char permutationname[256];
1926
1927         if (p->compiled)
1928                 return;
1929         p->compiled = true;
1930         p->program = 0;
1931
1932         permutationname[0] = 0;
1933         vertexstring   = R_GLSL_GetText(modeinfo->vertexfilename, true);
1934         geometrystring = R_GLSL_GetText(modeinfo->geometryfilename, false);
1935         fragmentstring = R_GLSL_GetText(modeinfo->fragmentfilename, false);
1936
1937         strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname));
1938
1939         // the first pretext is which type of shader to compile as
1940         // (later these will all be bound together as a program object)
1941         vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
1942         geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
1943         fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
1944
1945         // the second pretext is the mode (for example a light source)
1946         vertstrings_list[vertstrings_count++] = modeinfo->pretext;
1947         geomstrings_list[geomstrings_count++] = modeinfo->pretext;
1948         fragstrings_list[fragstrings_count++] = modeinfo->pretext;
1949         strlcat(permutationname, modeinfo->name, sizeof(permutationname));
1950
1951         // now add all the permutation pretexts
1952         for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
1953         {
1954                 if (permutation & (1<<i))
1955                 {
1956                         vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
1957                         geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
1958                         fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
1959                         strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
1960                 }
1961                 else
1962                 {
1963                         // keep line numbers correct
1964                         vertstrings_list[vertstrings_count++] = "\n";
1965                         geomstrings_list[geomstrings_count++] = "\n";
1966                         fragstrings_list[fragstrings_count++] = "\n";
1967                 }
1968         }
1969
1970         // now append the shader text itself
1971         vertstrings_list[vertstrings_count++] = vertexstring;
1972         geomstrings_list[geomstrings_count++] = geometrystring;
1973         fragstrings_list[fragstrings_count++] = fragmentstring;
1974
1975         // if any sources were NULL, clear the respective list
1976         if (!vertexstring)
1977                 vertstrings_count = 0;
1978         if (!geometrystring)
1979                 geomstrings_count = 0;
1980         if (!fragmentstring)
1981                 fragstrings_count = 0;
1982
1983         // compile the shader program
1984         if (vertstrings_count + geomstrings_count + fragstrings_count)
1985                 p->program = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, geomstrings_count, geomstrings_list, fragstrings_count, fragstrings_list);
1986         if (p->program)
1987         {
1988                 CHECKGLERROR
1989                 qglUseProgramObjectARB(p->program);CHECKGLERROR
1990                 // look up all the uniform variable names we care about, so we don't
1991                 // have to look them up every time we set them
1992
1993                 p->loc_Texture_First              = qglGetUniformLocationARB(p->program, "Texture_First");
1994                 p->loc_Texture_Second             = qglGetUniformLocationARB(p->program, "Texture_Second");
1995                 p->loc_Texture_GammaRamps         = qglGetUniformLocationARB(p->program, "Texture_GammaRamps");
1996                 p->loc_Texture_Normal             = qglGetUniformLocationARB(p->program, "Texture_Normal");
1997                 p->loc_Texture_Color              = qglGetUniformLocationARB(p->program, "Texture_Color");
1998                 p->loc_Texture_Gloss              = qglGetUniformLocationARB(p->program, "Texture_Gloss");
1999                 p->loc_Texture_Glow               = qglGetUniformLocationARB(p->program, "Texture_Glow");
2000                 p->loc_Texture_SecondaryNormal    = qglGetUniformLocationARB(p->program, "Texture_SecondaryNormal");
2001                 p->loc_Texture_SecondaryColor     = qglGetUniformLocationARB(p->program, "Texture_SecondaryColor");
2002                 p->loc_Texture_SecondaryGloss     = qglGetUniformLocationARB(p->program, "Texture_SecondaryGloss");
2003                 p->loc_Texture_SecondaryGlow      = qglGetUniformLocationARB(p->program, "Texture_SecondaryGlow");
2004                 p->loc_Texture_Pants              = qglGetUniformLocationARB(p->program, "Texture_Pants");
2005                 p->loc_Texture_Shirt              = qglGetUniformLocationARB(p->program, "Texture_Shirt");
2006                 p->loc_Texture_FogMask            = qglGetUniformLocationARB(p->program, "Texture_FogMask");
2007                 p->loc_Texture_Lightmap           = qglGetUniformLocationARB(p->program, "Texture_Lightmap");
2008                 p->loc_Texture_Deluxemap          = qglGetUniformLocationARB(p->program, "Texture_Deluxemap");
2009                 p->loc_Texture_Attenuation        = qglGetUniformLocationARB(p->program, "Texture_Attenuation");
2010                 p->loc_Texture_Cube               = qglGetUniformLocationARB(p->program, "Texture_Cube");
2011                 p->loc_Texture_Refraction         = qglGetUniformLocationARB(p->program, "Texture_Refraction");
2012                 p->loc_Texture_Reflection         = qglGetUniformLocationARB(p->program, "Texture_Reflection");
2013                 p->loc_Texture_ShadowMapRect      = qglGetUniformLocationARB(p->program, "Texture_ShadowMapRect");
2014                 p->loc_Texture_ShadowMapCube      = qglGetUniformLocationARB(p->program, "Texture_ShadowMapCube");
2015                 p->loc_Texture_ShadowMap2D        = qglGetUniformLocationARB(p->program, "Texture_ShadowMap2D");
2016                 p->loc_Texture_CubeProjection     = qglGetUniformLocationARB(p->program, "Texture_CubeProjection");
2017                 p->loc_Texture_ScreenDepth        = qglGetUniformLocationARB(p->program, "Texture_ScreenDepth");
2018                 p->loc_Texture_ScreenNormalMap    = qglGetUniformLocationARB(p->program, "Texture_ScreenNormalMap");
2019                 p->loc_Texture_ScreenDiffuse      = qglGetUniformLocationARB(p->program, "Texture_ScreenDiffuse");
2020                 p->loc_Texture_ScreenSpecular     = qglGetUniformLocationARB(p->program, "Texture_ScreenSpecular");
2021                 p->loc_Alpha                      = qglGetUniformLocationARB(p->program, "Alpha");
2022                 p->loc_BloomBlur_Parameters       = qglGetUniformLocationARB(p->program, "BloomBlur_Parameters");
2023                 p->loc_ClientTime                 = qglGetUniformLocationARB(p->program, "ClientTime");
2024                 p->loc_Color_Ambient              = qglGetUniformLocationARB(p->program, "Color_Ambient");
2025                 p->loc_Color_Diffuse              = qglGetUniformLocationARB(p->program, "Color_Diffuse");
2026                 p->loc_Color_Specular             = qglGetUniformLocationARB(p->program, "Color_Specular");
2027                 p->loc_Color_Glow                 = qglGetUniformLocationARB(p->program, "Color_Glow");
2028                 p->loc_Color_Pants                = qglGetUniformLocationARB(p->program, "Color_Pants");
2029                 p->loc_Color_Shirt                = qglGetUniformLocationARB(p->program, "Color_Shirt");
2030                 p->loc_DeferredColor_Ambient      = qglGetUniformLocationARB(p->program, "DeferredColor_Ambient");
2031                 p->loc_DeferredColor_Diffuse      = qglGetUniformLocationARB(p->program, "DeferredColor_Diffuse");
2032                 p->loc_DeferredColor_Specular     = qglGetUniformLocationARB(p->program, "DeferredColor_Specular");
2033                 p->loc_DeferredMod_Diffuse        = qglGetUniformLocationARB(p->program, "DeferredMod_Diffuse");
2034                 p->loc_DeferredMod_Specular       = qglGetUniformLocationARB(p->program, "DeferredMod_Specular");
2035                 p->loc_DistortScaleRefractReflect = qglGetUniformLocationARB(p->program, "DistortScaleRefractReflect");
2036                 p->loc_EyePosition                = qglGetUniformLocationARB(p->program, "EyePosition");
2037                 p->loc_FogColor                   = qglGetUniformLocationARB(p->program, "FogColor");
2038                 p->loc_FogHeightFade              = qglGetUniformLocationARB(p->program, "FogHeightFade");
2039                 p->loc_FogPlane                   = qglGetUniformLocationARB(p->program, "FogPlane");
2040                 p->loc_FogPlaneViewDist           = qglGetUniformLocationARB(p->program, "FogPlaneViewDist");
2041                 p->loc_FogRangeRecip              = qglGetUniformLocationARB(p->program, "FogRangeRecip");
2042                 p->loc_LightColor                 = qglGetUniformLocationARB(p->program, "LightColor");
2043                 p->loc_LightDir                   = qglGetUniformLocationARB(p->program, "LightDir");
2044                 p->loc_LightPosition              = qglGetUniformLocationARB(p->program, "LightPosition");
2045                 p->loc_OffsetMapping_Scale        = qglGetUniformLocationARB(p->program, "OffsetMapping_Scale");
2046                 p->loc_PixelSize                  = qglGetUniformLocationARB(p->program, "PixelSize");
2047                 p->loc_ReflectColor               = qglGetUniformLocationARB(p->program, "ReflectColor");
2048                 p->loc_ReflectFactor              = qglGetUniformLocationARB(p->program, "ReflectFactor");
2049                 p->loc_ReflectOffset              = qglGetUniformLocationARB(p->program, "ReflectOffset");
2050                 p->loc_RefractColor               = qglGetUniformLocationARB(p->program, "RefractColor");
2051                 p->loc_Saturation                 = qglGetUniformLocationARB(p->program, "Saturation");
2052                 p->loc_ScreenCenterRefractReflect = qglGetUniformLocationARB(p->program, "ScreenCenterRefractReflect");
2053                 p->loc_ScreenScaleRefractReflect  = qglGetUniformLocationARB(p->program, "ScreenScaleRefractReflect");
2054                 p->loc_ScreenToDepth              = qglGetUniformLocationARB(p->program, "ScreenToDepth");
2055                 p->loc_ShadowMap_Parameters       = qglGetUniformLocationARB(p->program, "ShadowMap_Parameters");
2056                 p->loc_ShadowMap_TextureScale     = qglGetUniformLocationARB(p->program, "ShadowMap_TextureScale");
2057                 p->loc_SpecularPower              = qglGetUniformLocationARB(p->program, "SpecularPower");
2058                 p->loc_UserVec1                   = qglGetUniformLocationARB(p->program, "UserVec1");
2059                 p->loc_UserVec2                   = qglGetUniformLocationARB(p->program, "UserVec2");
2060                 p->loc_UserVec3                   = qglGetUniformLocationARB(p->program, "UserVec3");
2061                 p->loc_UserVec4                   = qglGetUniformLocationARB(p->program, "UserVec4");
2062                 p->loc_ViewTintColor              = qglGetUniformLocationARB(p->program, "ViewTintColor");
2063                 p->loc_ViewToLight                = qglGetUniformLocationARB(p->program, "ViewToLight");
2064                 p->loc_ModelToLight               = qglGetUniformLocationARB(p->program, "ModelToLight");
2065                 p->loc_TexMatrix                  = qglGetUniformLocationARB(p->program, "TexMatrix");
2066                 p->loc_BackgroundTexMatrix        = qglGetUniformLocationARB(p->program, "BackgroundTexMatrix");
2067                 p->loc_ModelViewMatrix            = qglGetUniformLocationARB(p->program, "ModelViewMatrix");
2068                 p->loc_ModelViewProjectionMatrix  = qglGetUniformLocationARB(p->program, "ModelViewProjectionMatrix");
2069                 // initialize the samplers to refer to the texture units we use
2070                 if (p->loc_Texture_First           >= 0) qglUniform1iARB(p->loc_Texture_First          , GL20TU_FIRST);
2071                 if (p->loc_Texture_Second          >= 0) qglUniform1iARB(p->loc_Texture_Second         , GL20TU_SECOND);
2072                 if (p->loc_Texture_GammaRamps      >= 0) qglUniform1iARB(p->loc_Texture_GammaRamps     , GL20TU_GAMMARAMPS);
2073                 if (p->loc_Texture_Normal          >= 0) qglUniform1iARB(p->loc_Texture_Normal         , GL20TU_NORMAL);
2074                 if (p->loc_Texture_Color           >= 0) qglUniform1iARB(p->loc_Texture_Color          , GL20TU_COLOR);
2075                 if (p->loc_Texture_Gloss           >= 0) qglUniform1iARB(p->loc_Texture_Gloss          , GL20TU_GLOSS);
2076                 if (p->loc_Texture_Glow            >= 0) qglUniform1iARB(p->loc_Texture_Glow           , GL20TU_GLOW);
2077                 if (p->loc_Texture_SecondaryNormal >= 0) qglUniform1iARB(p->loc_Texture_SecondaryNormal, GL20TU_SECONDARY_NORMAL);
2078                 if (p->loc_Texture_SecondaryColor  >= 0) qglUniform1iARB(p->loc_Texture_SecondaryColor , GL20TU_SECONDARY_COLOR);
2079                 if (p->loc_Texture_SecondaryGloss  >= 0) qglUniform1iARB(p->loc_Texture_SecondaryGloss , GL20TU_SECONDARY_GLOSS);
2080                 if (p->loc_Texture_SecondaryGlow   >= 0) qglUniform1iARB(p->loc_Texture_SecondaryGlow  , GL20TU_SECONDARY_GLOW);
2081                 if (p->loc_Texture_Pants           >= 0) qglUniform1iARB(p->loc_Texture_Pants          , GL20TU_PANTS);
2082                 if (p->loc_Texture_Shirt           >= 0) qglUniform1iARB(p->loc_Texture_Shirt          , GL20TU_SHIRT);
2083                 if (p->loc_Texture_FogMask         >= 0) qglUniform1iARB(p->loc_Texture_FogMask        , GL20TU_FOGMASK);
2084                 if (p->loc_Texture_Lightmap        >= 0) qglUniform1iARB(p->loc_Texture_Lightmap       , GL20TU_LIGHTMAP);
2085                 if (p->loc_Texture_Deluxemap       >= 0) qglUniform1iARB(p->loc_Texture_Deluxemap      , GL20TU_DELUXEMAP);
2086                 if (p->loc_Texture_Attenuation     >= 0) qglUniform1iARB(p->loc_Texture_Attenuation    , GL20TU_ATTENUATION);
2087                 if (p->loc_Texture_Cube            >= 0) qglUniform1iARB(p->loc_Texture_Cube           , GL20TU_CUBE);
2088                 if (p->loc_Texture_Refraction      >= 0) qglUniform1iARB(p->loc_Texture_Refraction     , GL20TU_REFRACTION);
2089                 if (p->loc_Texture_Reflection      >= 0) qglUniform1iARB(p->loc_Texture_Reflection     , GL20TU_REFLECTION);
2090                 if (p->loc_Texture_ShadowMapRect   >= 0) qglUniform1iARB(p->loc_Texture_ShadowMapRect  , GL20TU_SHADOWMAPRECT);
2091                 if (p->loc_Texture_ShadowMapCube   >= 0) qglUniform1iARB(p->loc_Texture_ShadowMapCube  , GL20TU_SHADOWMAPCUBE);
2092                 if (p->loc_Texture_ShadowMap2D     >= 0) qglUniform1iARB(p->loc_Texture_ShadowMap2D    , GL20TU_SHADOWMAP2D);
2093                 if (p->loc_Texture_CubeProjection  >= 0) qglUniform1iARB(p->loc_Texture_CubeProjection , GL20TU_CUBEPROJECTION);
2094                 if (p->loc_Texture_ScreenDepth     >= 0) qglUniform1iARB(p->loc_Texture_ScreenDepth    , GL20TU_SCREENDEPTH);
2095                 if (p->loc_Texture_ScreenNormalMap >= 0) qglUniform1iARB(p->loc_Texture_ScreenNormalMap, GL20TU_SCREENNORMALMAP);
2096                 if (p->loc_Texture_ScreenDiffuse   >= 0) qglUniform1iARB(p->loc_Texture_ScreenDiffuse  , GL20TU_SCREENDIFFUSE);
2097                 if (p->loc_Texture_ScreenSpecular  >= 0) qglUniform1iARB(p->loc_Texture_ScreenSpecular , GL20TU_SCREENSPECULAR);
2098                 CHECKGLERROR
2099                 if (developer.integer)
2100                         Con_Printf("^5GLSL shader %s compiled.\n", permutationname);
2101         }
2102         else
2103                 Con_Printf("^1GLSL shader %s failed!  some features may not work properly.\n", permutationname);
2104
2105         // free the strings
2106         if (vertexstring)
2107                 Mem_Free(vertexstring);
2108         if (geometrystring)
2109                 Mem_Free(geometrystring);
2110         if (fragmentstring)
2111                 Mem_Free(fragmentstring);
2112 }
2113
2114 void R_SetupShader_SetPermutationGLSL(unsigned int mode, unsigned int permutation)
2115 {
2116         r_glsl_permutation_t *perm = R_GLSL_FindPermutation(mode, permutation);
2117         if (r_glsl_permutation != perm)
2118         {
2119                 r_glsl_permutation = perm;
2120                 if (!r_glsl_permutation->program)
2121                 {
2122                         if (!r_glsl_permutation->compiled)
2123                                 R_GLSL_CompilePermutation(perm, mode, permutation);
2124                         if (!r_glsl_permutation->program)
2125                         {
2126                                 // remove features until we find a valid permutation
2127                                 int i;
2128                                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
2129                                 {
2130                                         // reduce i more quickly whenever it would not remove any bits
2131                                         int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
2132                                         if (!(permutation & j))
2133                                                 continue;
2134                                         permutation -= j;
2135                                         r_glsl_permutation = R_GLSL_FindPermutation(mode, permutation);
2136                                         if (!r_glsl_permutation->compiled)
2137                                                 R_GLSL_CompilePermutation(perm, mode, permutation);
2138                                         if (r_glsl_permutation->program)
2139                                                 break;
2140                                 }
2141                                 if (i >= SHADERPERMUTATION_COUNT)
2142                                 {
2143                                         //Con_Printf("Could not find a working OpenGL 2.0 shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext);
2144                                         r_glsl_permutation = R_GLSL_FindPermutation(mode, permutation);
2145                                         qglUseProgramObjectARB(0);CHECKGLERROR
2146                                         return; // no bit left to clear, entire mode is broken
2147                                 }
2148                         }
2149                 }
2150                 CHECKGLERROR
2151                 qglUseProgramObjectARB(r_glsl_permutation->program);CHECKGLERROR
2152         }
2153         if (r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f);
2154 }
2155
2156 #ifdef SUPPORTCG
2157 #include <Cg/cgGL.h>
2158 struct r_cg_permutation_s;
2159 typedef struct r_cg_permutation_s
2160 {
2161         /// hash lookup data
2162         struct r_cg_permutation_s *hashnext;
2163         unsigned int mode;
2164         unsigned int permutation;
2165
2166         /// indicates if we have tried compiling this permutation already
2167         qboolean compiled;
2168         /// 0 if compilation failed
2169         CGprogram vprogram;
2170         CGprogram fprogram;
2171         /// locations of detected parameters in programs, or NULL if not found
2172         CGparameter vp_EyePosition;
2173         CGparameter vp_FogPlane;
2174         CGparameter vp_LightDir;
2175         CGparameter vp_LightPosition;
2176         CGparameter vp_ModelToLight;
2177         CGparameter vp_TexMatrix;
2178         CGparameter vp_BackgroundTexMatrix;
2179         CGparameter vp_ModelViewProjectionMatrix;
2180         CGparameter vp_ModelViewMatrix;
2181
2182         CGparameter fp_Texture_First;
2183         CGparameter fp_Texture_Second;
2184         CGparameter fp_Texture_GammaRamps;
2185         CGparameter fp_Texture_Normal;
2186         CGparameter fp_Texture_Color;
2187         CGparameter fp_Texture_Gloss;
2188         CGparameter fp_Texture_Glow;
2189         CGparameter fp_Texture_SecondaryNormal;
2190         CGparameter fp_Texture_SecondaryColor;
2191         CGparameter fp_Texture_SecondaryGloss;
2192         CGparameter fp_Texture_SecondaryGlow;
2193         CGparameter fp_Texture_Pants;
2194         CGparameter fp_Texture_Shirt;
2195         CGparameter fp_Texture_FogMask;
2196         CGparameter fp_Texture_Lightmap;
2197         CGparameter fp_Texture_Deluxemap;
2198         CGparameter fp_Texture_Attenuation;
2199         CGparameter fp_Texture_Cube;
2200         CGparameter fp_Texture_Refraction;
2201         CGparameter fp_Texture_Reflection;
2202         CGparameter fp_Texture_ShadowMapRect;
2203         CGparameter fp_Texture_ShadowMapCube;
2204         CGparameter fp_Texture_ShadowMap2D;
2205         CGparameter fp_Texture_CubeProjection;
2206         CGparameter fp_Texture_ScreenDepth;
2207         CGparameter fp_Texture_ScreenNormalMap;
2208         CGparameter fp_Texture_ScreenDiffuse;
2209         CGparameter fp_Texture_ScreenSpecular;
2210         CGparameter fp_Alpha;
2211         CGparameter fp_BloomBlur_Parameters;
2212         CGparameter fp_ClientTime;
2213         CGparameter fp_Color_Ambient;
2214         CGparameter fp_Color_Diffuse;
2215         CGparameter fp_Color_Specular;
2216         CGparameter fp_Color_Glow;
2217         CGparameter fp_Color_Pants;
2218         CGparameter fp_Color_Shirt;
2219         CGparameter fp_DeferredColor_Ambient;
2220         CGparameter fp_DeferredColor_Diffuse;
2221         CGparameter fp_DeferredColor_Specular;
2222         CGparameter fp_DeferredMod_Diffuse;
2223         CGparameter fp_DeferredMod_Specular;
2224         CGparameter fp_DistortScaleRefractReflect;
2225         CGparameter fp_EyePosition;
2226         CGparameter fp_FogColor;
2227         CGparameter fp_FogHeightFade;
2228         CGparameter fp_FogPlane;
2229         CGparameter fp_FogPlaneViewDist;
2230         CGparameter fp_FogRangeRecip;
2231         CGparameter fp_LightColor;
2232         CGparameter fp_LightDir;
2233         CGparameter fp_LightPosition;
2234         CGparameter fp_OffsetMapping_Scale;
2235         CGparameter fp_PixelSize;
2236         CGparameter fp_ReflectColor;
2237         CGparameter fp_ReflectFactor;
2238         CGparameter fp_ReflectOffset;
2239         CGparameter fp_RefractColor;
2240         CGparameter fp_Saturation;
2241         CGparameter fp_ScreenCenterRefractReflect;
2242         CGparameter fp_ScreenScaleRefractReflect;
2243         CGparameter fp_ScreenToDepth;
2244         CGparameter fp_ShadowMap_Parameters;
2245         CGparameter fp_ShadowMap_TextureScale;
2246         CGparameter fp_SpecularPower;
2247         CGparameter fp_UserVec1;
2248         CGparameter fp_UserVec2;
2249         CGparameter fp_UserVec3;
2250         CGparameter fp_UserVec4;
2251         CGparameter fp_ViewTintColor;
2252         CGparameter fp_ViewToLight;
2253 }
2254 r_cg_permutation_t;
2255
2256 /// information about each possible shader permutation
2257 r_cg_permutation_t *r_cg_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
2258 /// currently selected permutation
2259 r_cg_permutation_t *r_cg_permutation;
2260 /// storage for permutations linked in the hash table
2261 memexpandablearray_t r_cg_permutationarray;
2262
2263 #define CHECKCGERROR {CGerror err = cgGetError(), err2 = err;if (err){Con_Printf("%s:%i CG error %i: %s : %s\n", __FILE__, __LINE__, err, cgGetErrorString(err), cgGetLastErrorString(&err2));if (err == 1) Con_Printf("last listing:\n%s\n", cgGetLastListing(vid.cgcontext));}}
2264
2265 static r_cg_permutation_t *R_CG_FindPermutation(unsigned int mode, unsigned int permutation)
2266 {
2267         //unsigned int hashdepth = 0;
2268         unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
2269         r_cg_permutation_t *p;
2270         for (p = r_cg_permutationhash[mode][hashindex];p;p = p->hashnext)
2271         {
2272                 if (p->mode == mode && p->permutation == permutation)
2273                 {
2274                         //if (hashdepth > 10)
2275                         //      Con_Printf("R_CG_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
2276                         return p;
2277                 }
2278                 //hashdepth++;
2279         }
2280         p = (r_cg_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_cg_permutationarray);
2281         p->mode = mode;
2282         p->permutation = permutation;
2283         p->hashnext = r_cg_permutationhash[mode][hashindex];
2284         r_cg_permutationhash[mode][hashindex] = p;
2285         //if (hashdepth > 10)
2286         //      Con_Printf("R_CG_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
2287         return p;
2288 }
2289
2290 static char *R_CG_GetText(const char *filename, qboolean printfromdisknotice)
2291 {
2292         char *shaderstring;
2293         if (!filename || !filename[0])
2294                 return NULL;
2295         shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
2296         if (shaderstring)
2297         {
2298                 if (printfromdisknotice)
2299                         Con_DPrintf("from disk %s... ", filename);
2300                 return shaderstring;
2301         }
2302         else if (!strcmp(filename, "cg/default.cg"))
2303         {
2304                 shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(builtincgshaderstring) + 1);
2305                 memcpy(shaderstring, builtincgshaderstring, strlen(builtincgshaderstring) + 1);
2306         }
2307         return shaderstring;
2308 }
2309
2310 static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, unsigned int permutation)
2311 {
2312         int i;
2313         shadermodeinfo_t *modeinfo = cgshadermodeinfo + mode;
2314         int vertstrings_count = 0, vertstring_length = 0;
2315         int geomstrings_count = 0, geomstring_length = 0;
2316         int fragstrings_count = 0, fragstring_length = 0;
2317         char *t;
2318         char *vertexstring, *geometrystring, *fragmentstring;
2319         char *vertstring, *geomstring, *fragstring;
2320         const char *vertstrings_list[32+3];
2321         const char *geomstrings_list[32+3];
2322         const char *fragstrings_list[32+3];
2323         char permutationname[256];
2324         CGprofile vertexProfile;
2325         CGprofile fragmentProfile;
2326
2327         if (p->compiled)
2328                 return;
2329         p->compiled = true;
2330         p->vprogram = NULL;
2331         p->fprogram = NULL;
2332
2333         permutationname[0] = 0;
2334         vertexstring   = R_CG_GetText(modeinfo->vertexfilename, true);
2335         geometrystring = R_CG_GetText(modeinfo->geometryfilename, false);
2336         fragmentstring = R_CG_GetText(modeinfo->fragmentfilename, false);
2337
2338         strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname));
2339
2340         // the first pretext is which type of shader to compile as
2341         // (later these will all be bound together as a program object)
2342         vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
2343         geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
2344         fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
2345
2346         // the second pretext is the mode (for example a light source)
2347         vertstrings_list[vertstrings_count++] = modeinfo->pretext;
2348         geomstrings_list[geomstrings_count++] = modeinfo->pretext;
2349         fragstrings_list[fragstrings_count++] = modeinfo->pretext;
2350         strlcat(permutationname, modeinfo->name, sizeof(permutationname));
2351
2352         // now add all the permutation pretexts
2353         for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
2354         {
2355                 if (permutation & (1<<i))
2356                 {
2357                         vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
2358                         geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
2359                         fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
2360                         strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
2361                 }
2362                 else
2363                 {
2364                         // keep line numbers correct
2365                         vertstrings_list[vertstrings_count++] = "\n";
2366                         geomstrings_list[geomstrings_count++] = "\n";
2367                         fragstrings_list[fragstrings_count++] = "\n";
2368                 }
2369         }
2370
2371         // now append the shader text itself
2372         vertstrings_list[vertstrings_count++] = vertexstring;
2373         geomstrings_list[geomstrings_count++] = geometrystring;
2374         fragstrings_list[fragstrings_count++] = fragmentstring;
2375
2376         // if any sources were NULL, clear the respective list
2377         if (!vertexstring)
2378                 vertstrings_count = 0;
2379         if (!geometrystring)
2380                 geomstrings_count = 0;
2381         if (!fragmentstring)
2382                 fragstrings_count = 0;
2383
2384         vertstring_length = 0;
2385         for (i = 0;i < vertstrings_count;i++)
2386                 vertstring_length += strlen(vertstrings_list[i]);
2387         vertstring = t = Mem_Alloc(tempmempool, vertstring_length + 1);
2388         for (i = 0;i < vertstrings_count;t += strlen(vertstrings_list[i]), i++)
2389                 memcpy(t, vertstrings_list[i], strlen(vertstrings_list[i]));
2390
2391         geomstring_length = 0;
2392         for (i = 0;i < geomstrings_count;i++)
2393                 geomstring_length += strlen(geomstrings_list[i]);
2394         geomstring = t = Mem_Alloc(tempmempool, geomstring_length + 1);
2395         for (i = 0;i < geomstrings_count;t += strlen(geomstrings_list[i]), i++)
2396                 memcpy(t, geomstrings_list[i], strlen(geomstrings_list[i]));
2397
2398         fragstring_length = 0;
2399         for (i = 0;i < fragstrings_count;i++)
2400                 fragstring_length += strlen(fragstrings_list[i]);
2401         fragstring = t = Mem_Alloc(tempmempool, fragstring_length + 1);
2402         for (i = 0;i < fragstrings_count;t += strlen(fragstrings_list[i]), i++)
2403                 memcpy(t, fragstrings_list[i], strlen(fragstrings_list[i]));
2404
2405         CHECKGLERROR
2406         CHECKCGERROR
2407         //vertexProfile = CG_PROFILE_ARBVP1;
2408         //fragmentProfile = CG_PROFILE_ARBFP1;
2409         vertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);CHECKCGERROR
2410         fragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);CHECKCGERROR
2411         //cgGLSetOptimalOptions(vertexProfile);CHECKCGERROR
2412         //cgGLSetOptimalOptions(fragmentProfile);CHECKCGERROR
2413         //cgSetAutoCompile(vid.cgcontext, CG_COMPILE_MANUAL);CHECKCGERROR
2414         CHECKGLERROR
2415
2416         // compile the vertex program
2417         if (vertstring[0] && (p->vprogram = cgCreateProgram(vid.cgcontext, CG_SOURCE, vertstring, CG_PROFILE_ARBVP1, NULL, NULL)))
2418         {
2419                 CHECKCGERROR
2420                 cgCompileProgram(p->vprogram);CHECKCGERROR
2421                 if (!cgIsProgramCompiled(p->vprogram))
2422                 {
2423                         CHECKCGERROR
2424                         cgDestroyProgram(p->vprogram);CHECKCGERROR
2425                         p->vprogram = 0;
2426                 }
2427                 else
2428                 {
2429                         cgGLLoadProgram(p->vprogram);CHECKCGERROR CHECKGLERROR
2430                         cgGLEnableProfile(vertexProfile);CHECKCGERROR CHECKGLERROR
2431                         // look up all the uniform variable names we care about, so we don't
2432                         // have to look them up every time we set them
2433                         CHECKCGERROR
2434                         p->vp_EyePosition                = cgGetNamedParameter(p->vprogram, "EyePosition");
2435                         p->vp_FogPlane                   = cgGetNamedParameter(p->vprogram, "FogPlane");
2436                         p->vp_LightDir                   = cgGetNamedParameter(p->vprogram, "LightDir");
2437                         p->vp_LightPosition              = cgGetNamedParameter(p->vprogram, "LightPosition");
2438                         p->vp_ModelToLight               = cgGetNamedParameter(p->vprogram, "ModelToLight");
2439                         p->vp_TexMatrix                  = cgGetNamedParameter(p->vprogram, "TexMatrix");
2440                         p->vp_BackgroundTexMatrix        = cgGetNamedParameter(p->vprogram, "BackgroundTexMatrix");
2441                         p->vp_ModelViewProjectionMatrix  = cgGetNamedParameter(p->vprogram, "ModelViewProjectionMatrix");
2442                         p->vp_ModelViewMatrix            = cgGetNamedParameter(p->vprogram, "ModelViewMatrix");
2443                         CHECKCGERROR
2444                 }
2445         }
2446
2447         // compile the fragment program
2448         if (fragstring[0] && (p->fprogram = cgCreateProgram(vid.cgcontext, CG_SOURCE, fragstring, CG_PROFILE_ARBFP1, NULL, NULL)))
2449         {
2450                 cgCompileProgram(p->fprogram);CHECKCGERROR
2451                 if (!cgIsProgramCompiled(p->fprogram))
2452                 {
2453                         CHECKCGERROR
2454                         cgDestroyProgram(p->fprogram);CHECKCGERROR
2455                         p->fprogram = 0;
2456                 }
2457                 else
2458                 {
2459                         cgGLLoadProgram(p->fprogram);CHECKCGERROR CHECKGLERROR
2460                         cgGLEnableProfile(fragmentProfile);CHECKCGERROR CHECKGLERROR
2461                         CHECKCGERROR
2462                         p->fp_Texture_First              = cgGetNamedParameter(p->fprogram, "Texture_First");
2463                         p->fp_Texture_Second             = cgGetNamedParameter(p->fprogram, "Texture_Second");
2464                         p->fp_Texture_GammaRamps         = cgGetNamedParameter(p->fprogram, "Texture_GammaRamps");
2465                         p->fp_Texture_Normal             = cgGetNamedParameter(p->fprogram, "Texture_Normal");
2466                         p->fp_Texture_Color              = cgGetNamedParameter(p->fprogram, "Texture_Color");
2467                         p->fp_Texture_Gloss              = cgGetNamedParameter(p->fprogram, "Texture_Gloss");
2468                         p->fp_Texture_Glow               = cgGetNamedParameter(p->fprogram, "Texture_Glow");
2469                         p->fp_Texture_SecondaryNormal    = cgGetNamedParameter(p->fprogram, "Texture_SecondaryNormal");
2470                         p->fp_Texture_SecondaryColor     = cgGetNamedParameter(p->fprogram, "Texture_SecondaryColor");
2471                         p->fp_Texture_SecondaryGloss     = cgGetNamedParameter(p->fprogram, "Texture_SecondaryGloss");
2472                         p->fp_Texture_SecondaryGlow      = cgGetNamedParameter(p->fprogram, "Texture_SecondaryGlow");
2473                         p->fp_Texture_Pants              = cgGetNamedParameter(p->fprogram, "Texture_Pants");
2474                         p->fp_Texture_Shirt              = cgGetNamedParameter(p->fprogram, "Texture_Shirt");
2475                         p->fp_Texture_FogMask            = cgGetNamedParameter(p->fprogram, "Texture_FogMask");
2476                         p->fp_Texture_Lightmap           = cgGetNamedParameter(p->fprogram, "Texture_Lightmap");
2477                         p->fp_Texture_Deluxemap          = cgGetNamedParameter(p->fprogram, "Texture_Deluxemap");
2478                         p->fp_Texture_Attenuation        = cgGetNamedParameter(p->fprogram, "Texture_Attenuation");
2479                         p->fp_Texture_Cube               = cgGetNamedParameter(p->fprogram, "Texture_Cube");
2480                         p->fp_Texture_Refraction         = cgGetNamedParameter(p->fprogram, "Texture_Refraction");
2481                         p->fp_Texture_Reflection         = cgGetNamedParameter(p->fprogram, "Texture_Reflection");
2482                         p->fp_Texture_ShadowMapRect      = cgGetNamedParameter(p->fprogram, "Texture_ShadowMapRect");
2483                         p->fp_Texture_ShadowMapCube      = cgGetNamedParameter(p->fprogram, "Texture_ShadowMapCube");
2484                         p->fp_Texture_ShadowMap2D        = cgGetNamedParameter(p->fprogram, "Texture_ShadowMap2D");
2485                         p->fp_Texture_CubeProjection     = cgGetNamedParameter(p->fprogram, "Texture_CubeProjection");
2486                         p->fp_Texture_ScreenDepth        = cgGetNamedParameter(p->fprogram, "Texture_ScreenDepth");
2487                         p->fp_Texture_ScreenNormalMap    = cgGetNamedParameter(p->fprogram, "Texture_ScreenNormalMap");
2488                         p->fp_Texture_ScreenDiffuse      = cgGetNamedParameter(p->fprogram, "Texture_ScreenDiffuse");
2489                         p->fp_Texture_ScreenSpecular     = cgGetNamedParameter(p->fprogram, "Texture_ScreenSpecular");
2490                         p->fp_Alpha                      = cgGetNamedParameter(p->fprogram, "Alpha");
2491                         p->fp_BloomBlur_Parameters       = cgGetNamedParameter(p->fprogram, "BloomBlur_Parameters");
2492                         p->fp_ClientTime                 = cgGetNamedParameter(p->fprogram, "ClientTime");
2493                         p->fp_Color_Ambient              = cgGetNamedParameter(p->fprogram, "Color_Ambient");
2494                         p->fp_Color_Diffuse              = cgGetNamedParameter(p->fprogram, "Color_Diffuse");
2495                         p->fp_Color_Specular             = cgGetNamedParameter(p->fprogram, "Color_Specular");
2496                         p->fp_Color_Glow                 = cgGetNamedParameter(p->fprogram, "Color_Glow");
2497                         p->fp_Color_Pants                = cgGetNamedParameter(p->fprogram, "Color_Pants");
2498                         p->fp_Color_Shirt                = cgGetNamedParameter(p->fprogram, "Color_Shirt");
2499                         p->fp_DeferredColor_Ambient      = cgGetNamedParameter(p->fprogram, "DeferredColor_Ambient");
2500                         p->fp_DeferredColor_Diffuse      = cgGetNamedParameter(p->fprogram, "DeferredColor_Diffuse");
2501                         p->fp_DeferredColor_Specular     = cgGetNamedParameter(p->fprogram, "DeferredColor_Specular");
2502                         p->fp_DeferredMod_Diffuse        = cgGetNamedParameter(p->fprogram, "DeferredMod_Diffuse");
2503                         p->fp_DeferredMod_Specular       = cgGetNamedParameter(p->fprogram, "DeferredMod_Specular");
2504                         p->fp_DistortScaleRefractReflect = cgGetNamedParameter(p->fprogram, "DistortScaleRefractReflect");
2505                         p->fp_EyePosition                = cgGetNamedParameter(p->fprogram, "EyePosition");
2506                         p->fp_FogColor                   = cgGetNamedParameter(p->fprogram, "FogColor");
2507                         p->fp_FogHeightFade              = cgGetNamedParameter(p->fprogram, "FogHeightFade");
2508                         p->fp_FogPlane                   = cgGetNamedParameter(p->fprogram, "FogPlane");
2509                         p->fp_FogPlaneViewDist           = cgGetNamedParameter(p->fprogram, "FogPlaneViewDist");
2510                         p->fp_FogRangeRecip              = cgGetNamedParameter(p->fprogram, "FogRangeRecip");
2511                         p->fp_LightColor                 = cgGetNamedParameter(p->fprogram, "LightColor");
2512                         p->fp_LightDir                   = cgGetNamedParameter(p->fprogram, "LightDir");
2513                         p->fp_LightPosition              = cgGetNamedParameter(p->fprogram, "LightPosition");
2514                         p->fp_OffsetMapping_Scale        = cgGetNamedParameter(p->fprogram, "OffsetMapping_Scale");
2515                         p->fp_PixelSize                  = cgGetNamedParameter(p->fprogram, "PixelSize");
2516                         p->fp_ReflectColor               = cgGetNamedParameter(p->fprogram, "ReflectColor");
2517                         p->fp_ReflectFactor              = cgGetNamedParameter(p->fprogram, "ReflectFactor");
2518                         p->fp_ReflectOffset              = cgGetNamedParameter(p->fprogram, "ReflectOffset");
2519                         p->fp_RefractColor               = cgGetNamedParameter(p->fprogram, "RefractColor");
2520                         p->fp_Saturation                 = cgGetNamedParameter(p->fprogram, "Saturation");
2521                         p->fp_ScreenCenterRefractReflect = cgGetNamedParameter(p->fprogram, "ScreenCenterRefractReflect");
2522                         p->fp_ScreenScaleRefractReflect  = cgGetNamedParameter(p->fprogram, "ScreenScaleRefractReflect");
2523                         p->fp_ScreenToDepth              = cgGetNamedParameter(p->fprogram, "ScreenToDepth");
2524                         p->fp_ShadowMap_Parameters       = cgGetNamedParameter(p->fprogram, "ShadowMap_Parameters");
2525                         p->fp_ShadowMap_TextureScale     = cgGetNamedParameter(p->fprogram, "ShadowMap_TextureScale");
2526                         p->fp_SpecularPower              = cgGetNamedParameter(p->fprogram, "SpecularPower");
2527                         p->fp_UserVec1                   = cgGetNamedParameter(p->fprogram, "UserVec1");
2528                         p->fp_UserVec2                   = cgGetNamedParameter(p->fprogram, "UserVec2");
2529                         p->fp_UserVec3                   = cgGetNamedParameter(p->fprogram, "UserVec3");
2530                         p->fp_UserVec4                   = cgGetNamedParameter(p->fprogram, "UserVec4");
2531                         p->fp_ViewTintColor              = cgGetNamedParameter(p->fprogram, "ViewTintColor");
2532                         p->fp_ViewToLight                = cgGetNamedParameter(p->fprogram, "ViewToLight");
2533                         CHECKCGERROR
2534                 }
2535         }
2536
2537         if ((p->vprogram || !vertstring[0]) && (p->fprogram || !fragstring[0]))
2538                 Con_DPrintf("^5CG shader %s compiled.\n", permutationname);
2539         else
2540                 Con_Printf("^1CG shader %s failed!  some features may not work properly.\n", permutationname);
2541
2542         // free the strings
2543         if (vertstring)
2544                 Mem_Free(vertstring);
2545         if (geomstring)
2546                 Mem_Free(geomstring);
2547         if (fragstring)
2548                 Mem_Free(fragstring);
2549         if (vertexstring)
2550                 Mem_Free(vertexstring);
2551         if (geometrystring)
2552                 Mem_Free(geometrystring);
2553         if (fragmentstring)
2554                 Mem_Free(fragmentstring);
2555 }
2556
2557 void R_SetupShader_SetPermutationCG(unsigned int mode, unsigned int permutation)
2558 {
2559         r_cg_permutation_t *perm = R_CG_FindPermutation(mode, permutation);
2560         CHECKGLERROR
2561         CHECKCGERROR
2562         if (r_cg_permutation != perm)
2563         {
2564                 r_cg_permutation = perm;
2565                 if (!r_cg_permutation->vprogram && !r_cg_permutation->fprogram)
2566                 {
2567                         if (!r_cg_permutation->compiled)
2568                                 R_CG_CompilePermutation(perm, mode, permutation);
2569                         if (!r_cg_permutation->vprogram && !r_cg_permutation->fprogram)
2570                         {
2571                                 // remove features until we find a valid permutation
2572                                 int i;
2573                                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
2574                                 {
2575                                         // reduce i more quickly whenever it would not remove any bits
2576                                         int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
2577                                         if (!(permutation & j))
2578                                                 continue;
2579                                         permutation -= j;
2580                                         r_cg_permutation = R_CG_FindPermutation(mode, permutation);
2581                                         if (!r_cg_permutation->compiled)
2582                                                 R_CG_CompilePermutation(perm, mode, permutation);
2583                                         if (r_cg_permutation->vprogram || r_cg_permutation->fprogram)
2584                                                 break;
2585                                 }
2586                                 if (i >= SHADERPERMUTATION_COUNT)
2587                                 {
2588                                         //Con_Printf("Could not find a working Cg shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext);
2589                                         r_cg_permutation = R_CG_FindPermutation(mode, permutation);
2590                                         return; // no bit left to clear, entire mode is broken
2591                                 }
2592                         }
2593                 }
2594                 CHECKGLERROR
2595                 CHECKCGERROR
2596                 if (r_cg_permutation->vprogram)
2597                 {
2598                         //cgGLLoadProgram(r_cg_permutation->vprogram);CHECKCGERROR CHECKGLERROR
2599                         cgGLBindProgram(r_cg_permutation->vprogram);CHECKCGERROR CHECKGLERROR
2600                         //cgGLEnableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
2601                 }
2602                 else
2603                 {
2604                         //cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
2605                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
2606                 }
2607                 if (r_cg_permutation->fprogram)
2608                 {
2609                         cgGLLoadProgram(r_cg_permutation->fprogram);CHECKCGERROR CHECKGLERROR
2610                         cgGLBindProgram(r_cg_permutation->fprogram);CHECKCGERROR CHECKGLERROR
2611                         cgGLEnableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
2612                 }
2613                 else
2614                 {
2615                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
2616                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
2617                 }
2618         }
2619         CHECKCGERROR
2620         if (r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR
2621 }
2622
2623 void CG_BindTexture(CGparameter param, int texnum)
2624 {
2625         cgGLSetTextureParameter(param, texnum);
2626         cgGLEnableTextureParameter(param);
2627 }
2628 #endif
2629
2630 void R_GLSL_Restart_f(void)
2631 {
2632         unsigned int i, limit;
2633         switch(vid.renderpath)
2634         {
2635         case RENDERPATH_GL20:
2636                 {
2637                         r_glsl_permutation_t *p;
2638                         limit = Mem_ExpandableArray_IndexRange(&r_glsl_permutationarray);
2639                         for (i = 0;i < limit;i++)
2640                         {
2641                                 if ((p = (r_glsl_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_glsl_permutationarray, i)))
2642                                 {
2643                                         GL_Backend_FreeProgram(p->program);
2644                                         Mem_ExpandableArray_FreeRecord(&r_glsl_permutationarray, (void*)p);
2645                                 }
2646                         }
2647                         memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
2648                 }
2649                 break;
2650         case RENDERPATH_CGGL:
2651 #ifdef SUPPORTCG
2652                 {
2653                         r_cg_permutation_t *p;
2654                         limit = Mem_ExpandableArray_IndexRange(&r_cg_permutationarray);
2655                         for (i = 0;i < limit;i++)
2656                         {
2657                                 if ((p = (r_cg_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_cg_permutationarray, i)))
2658                                 {
2659                                         if (p->vprogram)
2660                                                 cgDestroyProgram(p->vprogram);
2661                                         if (p->fprogram)
2662                                                 cgDestroyProgram(p->fprogram);
2663                                         Mem_ExpandableArray_FreeRecord(&r_cg_permutationarray, (void*)p);
2664                                 }
2665                         }
2666                 }
2667                 memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash));
2668                 break;
2669 #endif
2670         case RENDERPATH_GL13:
2671         case RENDERPATH_GL11:
2672                 break;
2673         }
2674 }
2675
2676 void R_GLSL_DumpShader_f(void)
2677 {
2678         int i;
2679         qfile_t *file;
2680
2681         file = FS_OpenRealFile("glsl/default.glsl", "w", false);
2682         if (file)
2683         {
2684                 FS_Print(file, "/* The engine may define the following macros:\n");
2685                 FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
2686                 for (i = 0;i < SHADERMODE_COUNT;i++)
2687                         FS_Print(file, glslshadermodeinfo[i].pretext);
2688                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
2689                         FS_Print(file, shaderpermutationinfo[i].pretext);
2690                 FS_Print(file, "*/\n");
2691                 FS_Print(file, builtinshaderstring);
2692                 FS_Close(file);
2693                 Con_Printf("glsl/default.glsl written\n");
2694         }
2695         else
2696                 Con_Printf("failed to write to glsl/default.glsl\n");
2697
2698 #ifdef SUPPORTCG
2699         file = FS_OpenRealFile("cg/default.cg", "w", false);
2700         if (file)
2701         {
2702                 FS_Print(file, "/* The engine may define the following macros:\n");
2703                 FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
2704                 for (i = 0;i < SHADERMODE_COUNT;i++)
2705                         FS_Print(file, cgshadermodeinfo[i].pretext);
2706                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
2707                         FS_Print(file, shaderpermutationinfo[i].pretext);
2708                 FS_Print(file, "*/\n");
2709                 FS_Print(file, builtincgshaderstring);
2710                 FS_Close(file);
2711                 Con_Printf("cg/default.cg written\n");
2712         }
2713         else
2714                 Con_Printf("failed to write to cg/default.cg\n");
2715 #endif
2716 }
2717
2718 void R_SetupShader_Generic(rtexture_t *first, rtexture_t *second, int texturemode, int rgbscale)
2719 {
2720         if (!second)
2721                 texturemode = GL_MODULATE;
2722         switch (vid.renderpath)
2723         {
2724         case RENDERPATH_GL20:
2725                 R_SetupShader_SetPermutationGLSL(SHADERMODE_GENERIC, (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (r_shadow_glossexact.integer ? SHADERPERMUTATION_EXACTSPECULARMATH : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0))));
2726                 if (r_glsl_permutation->loc_Texture_First ) R_Mesh_TexBind(GL20TU_FIRST , R_GetTexture(first ));
2727                 if (r_glsl_permutation->loc_Texture_Second) R_Mesh_TexBind(GL20TU_SECOND, R_GetTexture(second));
2728                 break;
2729         case RENDERPATH_CGGL:
2730 #ifdef SUPPORTCG
2731                 CHECKCGERROR
2732                 R_SetupShader_SetPermutationCG(SHADERMODE_GENERIC, (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (r_shadow_glossexact.integer ? SHADERPERMUTATION_EXACTSPECULARMATH : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0))));
2733                 if (r_cg_permutation->fp_Texture_First ) CG_BindTexture(r_cg_permutation->fp_Texture_First , R_GetTexture(first ));CHECKCGERROR
2734                 if (r_cg_permutation->fp_Texture_Second) CG_BindTexture(r_cg_permutation->fp_Texture_Second, R_GetTexture(second));CHECKCGERROR
2735 #endif
2736                 break;
2737         case RENDERPATH_GL13:
2738                 R_Mesh_TexBind(0, R_GetTexture(first ));
2739                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
2740                 R_Mesh_TexBind(1, R_GetTexture(second));
2741                 if (second)
2742                         R_Mesh_TexCombine(1, texturemode, texturemode, rgbscale, 1);
2743                 break;
2744         case RENDERPATH_GL11:
2745                 R_Mesh_TexBind(0, R_GetTexture(first ));
2746                 break;
2747         }
2748 }
2749
2750 void R_SetupShader_DepthOrShadow(void)
2751 {
2752         switch (vid.renderpath)
2753         {
2754         case RENDERPATH_GL20:
2755                 R_SetupShader_SetPermutationGLSL(SHADERMODE_DEPTH_OR_SHADOW, 0);
2756                 break;
2757         case RENDERPATH_CGGL:
2758 #ifdef SUPPORTCG
2759                 R_SetupShader_SetPermutationCG(SHADERMODE_DEPTH_OR_SHADOW, 0);
2760 #endif
2761                 break;
2762         case RENDERPATH_GL13:
2763                 R_Mesh_TexBind(0, 0);
2764                 R_Mesh_TexBind(1, 0);
2765                 break;
2766         case RENDERPATH_GL11:
2767                 R_Mesh_TexBind(0, 0);
2768                 break;
2769         }
2770 }
2771
2772 void R_SetupShader_ShowDepth(void)
2773 {
2774         switch (vid.renderpath)
2775         {
2776         case RENDERPATH_GL20:
2777                 R_SetupShader_SetPermutationGLSL(SHADERMODE_SHOWDEPTH, 0);
2778                 break;
2779         case RENDERPATH_CGGL:
2780 #ifdef SUPPORTCG
2781                 R_SetupShader_SetPermutationCG(SHADERMODE_SHOWDEPTH, 0);
2782 #endif
2783                 break;
2784         case RENDERPATH_GL13:
2785                 break;
2786         case RENDERPATH_GL11:
2787                 break;
2788         }
2789 }
2790
2791 extern qboolean r_shadow_usingdeferredprepass;
2792 extern cvar_t r_shadow_deferred_8bitrange;
2793 extern rtexture_t *r_shadow_attenuationgradienttexture;
2794 extern rtexture_t *r_shadow_attenuation2dtexture;
2795 extern rtexture_t *r_shadow_attenuation3dtexture;
2796 extern qboolean r_shadow_usingshadowmaprect;
2797 extern qboolean r_shadow_usingshadowmapcube;
2798 extern qboolean r_shadow_usingshadowmap2d;
2799 extern float r_shadow_shadowmap_texturescale[2];
2800 extern float r_shadow_shadowmap_parameters[4];
2801 extern qboolean r_shadow_shadowmapvsdct;
2802 extern qboolean r_shadow_shadowmapsampler;
2803 extern int r_shadow_shadowmappcf;
2804 extern rtexture_t *r_shadow_shadowmaprectangletexture;
2805 extern rtexture_t *r_shadow_shadowmap2dtexture;
2806 extern rtexture_t *r_shadow_shadowmapcubetexture[R_SHADOW_SHADOWMAP_NUMCUBEMAPS];
2807 extern rtexture_t *r_shadow_shadowmapvsdcttexture;
2808 extern int r_shadow_shadowmaplod; // changes for each light based on distance
2809 extern int r_shadow_prepass_width;
2810 extern int r_shadow_prepass_height;
2811 extern rtexture_t *r_shadow_prepassgeometrydepthtexture;
2812 extern rtexture_t *r_shadow_prepassgeometrynormalmaptexture;
2813 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
2814 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
2815 void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass)
2816 {
2817         // select a permutation of the lighting shader appropriate to this
2818         // combination of texture, entity, light source, and fogging, only use the
2819         // minimum features necessary to avoid wasting rendering time in the
2820         // fragment shader on features that are not being used
2821         unsigned int permutation = 0;
2822         unsigned int mode = 0;
2823         float m16f[16];
2824         // TODO: implement geometry-shader based shadow volumes someday
2825         if (r_glsl_offsetmapping.integer)
2826         {
2827                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
2828                 if (r_glsl_offsetmapping_reliefmapping.integer)
2829                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
2830         }
2831         if (rsurfacepass == RSURFPASS_BACKGROUND)
2832         {
2833                 // distorted background
2834                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
2835                         mode = SHADERMODE_WATER;
2836                 else
2837                         mode = SHADERMODE_REFRACTION;
2838         }
2839         else if (rsurfacepass == RSURFPASS_DEFERREDGEOMETRY)
2840         {
2841                 // normalmap (deferred prepass), may use alpha test on diffuse
2842                 mode = SHADERMODE_DEFERREDGEOMETRY;
2843                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2844                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2845                 if (r_glsl_offsetmapping.integer)
2846                 {
2847                         permutation |= SHADERPERMUTATION_OFFSETMAPPING;
2848                         if (r_glsl_offsetmapping_reliefmapping.integer)
2849                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
2850                 }
2851         }
2852         else if (rsurfacepass == RSURFPASS_RTLIGHT)
2853         {
2854                 // light source
2855                 mode = SHADERMODE_LIGHTSOURCE;
2856                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2857                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2858                 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
2859                         permutation |= SHADERPERMUTATION_CUBEFILTER;
2860                 if (diffusescale > 0)
2861                         permutation |= SHADERPERMUTATION_DIFFUSE;
2862                 if (specularscale > 0)
2863                         permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
2864                 if (r_refdef.fogenabled)
2865                         permutation |= r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE;
2866                 if (rsurface.texture->colormapping)
2867                         permutation |= SHADERPERMUTATION_COLORMAPPING;
2868                 if (r_shadow_usingshadowmaprect || r_shadow_usingshadowmap2d || r_shadow_usingshadowmapcube)
2869                 {
2870                         if (r_shadow_usingshadowmaprect)
2871                                 permutation |= SHADERPERMUTATION_SHADOWMAPRECT;
2872                         if (r_shadow_usingshadowmap2d)
2873                                 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
2874                         if (r_shadow_usingshadowmapcube)
2875                                 permutation |= SHADERPERMUTATION_SHADOWMAPCUBE;
2876                         else if(r_shadow_shadowmapvsdct)
2877                                 permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT;
2878
2879                         if (r_shadow_shadowmapsampler)
2880                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
2881                         if (r_shadow_shadowmappcf > 1)
2882                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
2883                         else if (r_shadow_shadowmappcf)
2884                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
2885                 }
2886         }
2887         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
2888         {
2889                 // unshaded geometry (fullbright or ambient model lighting)
2890                 mode = SHADERMODE_FLATCOLOR;
2891                 ambientscale = diffusescale = specularscale = 0;
2892                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2893                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2894                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
2895                         permutation |= SHADERPERMUTATION_GLOW;
2896                 if (r_refdef.fogenabled)
2897                         permutation |= r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE;
2898                 if (rsurface.texture->colormapping)
2899                         permutation |= SHADERPERMUTATION_COLORMAPPING;
2900                 if (r_glsl_offsetmapping.integer)
2901                 {
2902                         permutation |= SHADERPERMUTATION_OFFSETMAPPING;
2903                         if (r_glsl_offsetmapping_reliefmapping.integer)
2904                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
2905                 }
2906                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
2907                         permutation |= SHADERPERMUTATION_REFLECTION;
2908         }
2909         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT_DIRECTIONAL)
2910         {
2911                 // directional model lighting
2912                 mode = SHADERMODE_LIGHTDIRECTION;
2913                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2914                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2915                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
2916                         permutation |= SHADERPERMUTATION_GLOW;
2917                 permutation |= SHADERPERMUTATION_DIFFUSE;
2918                 if (specularscale > 0)
2919                         permutation |= SHADERPERMUTATION_SPECULAR;
2920                 if (r_refdef.fogenabled)
2921                         permutation |= r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE;
2922                 if (rsurface.texture->colormapping)
2923                         permutation |= SHADERPERMUTATION_COLORMAPPING;
2924                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
2925                         permutation |= SHADERPERMUTATION_REFLECTION;
2926                 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
2927                         permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
2928         }
2929         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
2930         {
2931                 // ambient model lighting
2932                 mode = SHADERMODE_LIGHTDIRECTION;
2933                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2934                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2935                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
2936                         permutation |= SHADERPERMUTATION_GLOW;
2937                 if (r_refdef.fogenabled)
2938                         permutation |= r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE;
2939                 if (rsurface.texture->colormapping)
2940                         permutation |= SHADERPERMUTATION_COLORMAPPING;
2941                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
2942                         permutation |= SHADERPERMUTATION_REFLECTION;
2943                 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
2944                         permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
2945         }
2946         else
2947         {
2948                 // lightmapped wall
2949                 if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping)
2950                 {
2951                         // deluxemapping (light direction texture)
2952                         if (rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping && r_refdef.scene.worldmodel->brushq3.deluxemapping_modelspace)
2953                                 mode = SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE;
2954                         else
2955                                 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
2956                         permutation |= SHADERPERMUTATION_DIFFUSE;
2957                         if (specularscale > 0)
2958                                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
2959                 }
2960                 else if (r_glsl_deluxemapping.integer >= 2)
2961                 {
2962                         // fake deluxemapping (uniform light direction in tangentspace)
2963                         mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
2964                         permutation |= SHADERPERMUTATION_DIFFUSE;
2965                         if (specularscale > 0)
2966                                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
2967                 }
2968                 else if (rsurface.uselightmaptexture)
2969                 {
2970                         // ordinary lightmapping (q1bsp, q3bsp)
2971                         mode = SHADERMODE_LIGHTMAP;
2972                 }
2973                 else
2974                 {
2975                         // ordinary vertex coloring (q3bsp)
2976                         mode = SHADERMODE_VERTEXCOLOR;
2977                 }
2978                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2979                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2980                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
2981                         permutation |= SHADERPERMUTATION_GLOW;
2982                 if (r_refdef.fogenabled)
2983                         permutation |= r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE;
2984                 if (rsurface.texture->colormapping)
2985                         permutation |= SHADERPERMUTATION_COLORMAPPING;
2986                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
2987                         permutation |= SHADERPERMUTATION_REFLECTION;
2988                 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
2989                         permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
2990         }
2991         if(permutation & SHADERPERMUTATION_SPECULAR)
2992                 if(r_shadow_glossexact.integer)
2993                         permutation |= SHADERPERMUTATION_EXACTSPECULARMATH;
2994         if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) && r_shadow_usingdeferredprepass)
2995                 permutation |= SHADERPERMUTATION_ALPHAKILL;
2996         switch(vid.renderpath)
2997         {
2998         case RENDERPATH_GL20:
2999                 R_SetupShader_SetPermutationGLSL(mode, permutation);
3000                 if (mode == SHADERMODE_LIGHTSOURCE)
3001                 {
3002                         if (r_glsl_permutation->loc_ModelToLight >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelToLight, 1, false, m16f);}
3003                         if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
3004                         if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
3005                         if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, rsurface.colormod[0] * ambientscale, rsurface.colormod[1] * ambientscale, rsurface.colormod[2] * ambientscale);
3006                         if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, rsurface.colormod[0] * diffusescale, rsurface.colormod[1] * diffusescale, rsurface.colormod[2] * diffusescale);
3007                         if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Specular, specularscale, specularscale, specularscale);
3008
3009                         // additive passes are only darkened by fog, not tinted
3010                         if (r_glsl_permutation->loc_FogColor >= 0)
3011                                 qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
3012                         if (r_glsl_permutation->loc_ShadowMap_TextureScale >= 0) qglUniform2fARB(r_glsl_permutation->loc_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);
3013                         if (r_glsl_permutation->loc_ShadowMap_Parameters >= 0) qglUniform4fARB(r_glsl_permutation->loc_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);
3014                         if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));
3015                 }
3016                 else
3017                 {
3018                         if (mode == SHADERMODE_FLATCOLOR)
3019                         {
3020                                 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, rsurface.colormod[0], rsurface.colormod[1], rsurface.colormod[2]);
3021                         }
3022                         else if (mode == SHADERMODE_LIGHTDIRECTION)
3023                         {
3024                                 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, (r_refdef.scene.ambient + rsurface.modellight_ambient[0] * r_refdef.lightmapintensity) * rsurface.colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity) * rsurface.colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity) * rsurface.colormod[2]);
3025                                 if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, r_refdef.lightmapintensity, r_refdef.lightmapintensity, r_refdef.lightmapintensity);
3026                                 if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Specular, r_refdef.lightmapintensity * specularscale, r_refdef.lightmapintensity * specularscale, r_refdef.lightmapintensity * specularscale);
3027                                 if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Diffuse, rsurface.colormod[0] * r_shadow_deferred_8bitrange.value, rsurface.colormod[1] * r_shadow_deferred_8bitrange.value, rsurface.colormod[2] * r_shadow_deferred_8bitrange.value);
3028                                 if (r_glsl_permutation->loc_DeferredMod_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);
3029                                 if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, rsurface.modellight_diffuse[0], rsurface.modellight_diffuse[1], rsurface.modellight_diffuse[2]);
3030                                 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]);
3031                         }
3032                         else
3033                         {
3034                                 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, r_refdef.scene.ambient * rsurface.colormod[0], r_refdef.scene.ambient * rsurface.colormod[1], r_refdef.scene.ambient * rsurface.colormod[2]);
3035                                 if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, rsurface.texture->lightmapcolor[0], rsurface.texture->lightmapcolor[1], rsurface.texture->lightmapcolor[2]);
3036                                 if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Specular, r_refdef.lightmapintensity * specularscale, r_refdef.lightmapintensity * specularscale, r_refdef.lightmapintensity * specularscale);
3037                                 if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Diffuse, rsurface.colormod[0] * diffusescale * r_shadow_deferred_8bitrange.value, rsurface.colormod[1] * diffusescale * r_shadow_deferred_8bitrange.value, rsurface.colormod[2] * diffusescale * r_shadow_deferred_8bitrange.value);
3038                                 if (r_glsl_permutation->loc_DeferredMod_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);
3039                         }
3040                         // additive passes are only darkened by fog, not tinted
3041                         if (r_glsl_permutation->loc_FogColor >= 0)
3042                         {
3043                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
3044                                         qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
3045                                 else
3046                                         qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
3047                         }
3048                         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);
3049                         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]);
3050                         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]);
3051                         if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_RefractColor, 1, rsurface.texture->refractcolor4f);
3052                         if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_ReflectColor, 1, rsurface.texture->reflectcolor4f);
3053                         if (r_glsl_permutation->loc_ReflectFactor >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
3054                         if (r_glsl_permutation->loc_ReflectOffset >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectOffset, rsurface.texture->reflectmin);
3055                         if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));
3056                 }
3057                 if (r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f);
3058                 if (r_glsl_permutation->loc_TexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_TexMatrix, 1, false, m16f);}
3059                 if (r_glsl_permutation->loc_BackgroundTexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_BackgroundTexMatrix, 1, false, m16f);}
3060                 if (r_glsl_permutation->loc_Color_Glow >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);
3061                 if (r_glsl_permutation->loc_Alpha >= 0) qglUniform1fARB(r_glsl_permutation->loc_Alpha, rsurface.texture->lightmapcolor[3]);
3062                 if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
3063                 if (r_glsl_permutation->loc_Color_Pants >= 0)
3064                 {
3065                         if (rsurface.texture->pantstexture)
3066                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
3067                         else
3068                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, 0, 0, 0);
3069                 }
3070                 if (r_glsl_permutation->loc_Color_Shirt >= 0)
3071                 {
3072                         if (rsurface.texture->shirttexture)
3073                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
3074                         else
3075                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
3076                 }
3077                 if (r_glsl_permutation->loc_FogPlane >= 0) qglUniform4fARB(r_glsl_permutation->loc_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);
3078                 if (r_glsl_permutation->loc_FogPlaneViewDist >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogPlaneViewDist, rsurface.fogplaneviewdist);
3079                 if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, rsurface.fograngerecip);
3080                 if (r_glsl_permutation->loc_FogHeightFade >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogHeightFade, rsurface.fogheightfade);
3081                 if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);
3082                 if (r_glsl_permutation->loc_ScreenToDepth >= 0) qglUniform2fARB(r_glsl_permutation->loc_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
3083
3084         //      if (r_glsl_permutation->loc_Texture_First           >= 0) R_Mesh_TexBind(GL20TU_FIRST             ,          R_GetTexture(r_texture_white                                     ));
3085         //      if (r_glsl_permutation->loc_Texture_Second          >= 0) R_Mesh_TexBind(GL20TU_SECOND            ,          R_GetTexture(r_texture_white                                     ));
3086         //      if (r_glsl_permutation->loc_Texture_GammaRamps      >= 0) R_Mesh_TexBind(GL20TU_GAMMARAMPS        ,          R_GetTexture(r_texture_gammaramps                                ));
3087                 if (r_glsl_permutation->loc_Texture_Normal          >= 0) R_Mesh_TexBind(GL20TU_NORMAL            ,          R_GetTexture(rsurface.texture->nmaptexture                       ));
3088                 if (r_glsl_permutation->loc_Texture_Color           >= 0) R_Mesh_TexBind(GL20TU_COLOR             ,          R_GetTexture(rsurface.texture->basetexture                       ));
3089                 if (r_glsl_permutation->loc_Texture_Gloss           >= 0) R_Mesh_TexBind(GL20TU_GLOSS             ,          R_GetTexture(rsurface.texture->glosstexture                      ));
3090                 if (r_glsl_permutation->loc_Texture_Glow            >= 0) R_Mesh_TexBind(GL20TU_GLOW              ,          R_GetTexture(rsurface.texture->glowtexture                       ));
3091                 if (r_glsl_permutation->loc_Texture_SecondaryNormal >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL  ,          R_GetTexture(rsurface.texture->backgroundnmaptexture             ));
3092                 if (r_glsl_permutation->loc_Texture_SecondaryColor  >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_COLOR   ,          R_GetTexture(rsurface.texture->backgroundbasetexture             ));
3093                 if (r_glsl_permutation->loc_Texture_SecondaryGloss  >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS   ,          R_GetTexture(rsurface.texture->backgroundglosstexture            ));
3094                 if (r_glsl_permutation->loc_Texture_SecondaryGlow   >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_GLOW    ,          R_GetTexture(rsurface.texture->backgroundglowtexture             ));
3095                 if (r_glsl_permutation->loc_Texture_Pants           >= 0) R_Mesh_TexBind(GL20TU_PANTS             ,          R_GetTexture(rsurface.texture->pantstexture                      ));
3096                 if (r_glsl_permutation->loc_Texture_Shirt           >= 0) R_Mesh_TexBind(GL20TU_SHIRT             ,          R_GetTexture(rsurface.texture->shirttexture                      ));
3097                 if (r_glsl_permutation->loc_Texture_FogMask         >= 0) R_Mesh_TexBind(GL20TU_FOGMASK           ,          R_GetTexture(r_texture_fogattenuation                            ));
3098                 if (r_glsl_permutation->loc_Texture_Lightmap        >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP          ,          R_GetTexture(r_texture_white                                     ));
3099                 if (r_glsl_permutation->loc_Texture_Deluxemap       >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP          ,          R_GetTexture(r_texture_blanknormalmap                            ));
3100                 if (r_glsl_permutation->loc_Texture_Attenuation     >= 0) R_Mesh_TexBind(GL20TU_ATTENUATION       ,          R_GetTexture(r_shadow_attenuationgradienttexture                 ));
3101                 if (r_glsl_permutation->loc_Texture_Refraction      >= 0) R_Mesh_TexBind(GL20TU_REFRACTION        ,          R_GetTexture(r_texture_white                                     ));
3102                 if (r_glsl_permutation->loc_Texture_Reflection      >= 0) R_Mesh_TexBind(GL20TU_REFLECTION        ,          R_GetTexture(r_texture_white                                     ));
3103                 if (r_glsl_permutation->loc_Texture_ScreenDepth     >= 0) R_Mesh_TexBindAll(GL20TU_SCREENDEPTH    , 0, 0, 0, R_GetTexture(r_shadow_prepassgeometrydepthtexture                ));
3104                 if (r_glsl_permutation->loc_Texture_ScreenNormalMap >= 0) R_Mesh_TexBindAll(GL20TU_SCREENNORMALMAP, 0, 0, 0, R_GetTexture(r_shadow_prepassgeometrynormalmaptexture            ));
3105                 if (r_glsl_permutation->loc_Texture_ScreenDiffuse   >= 0) R_Mesh_TexBindAll(GL20TU_SCREENDIFFUSE  , 0, 0, 0, R_GetTexture(r_shadow_prepasslightingdiffusetexture              ));
3106                 if (r_glsl_permutation->loc_Texture_ScreenSpecular  >= 0) R_Mesh_TexBindAll(GL20TU_SCREENSPECULAR , 0, 0, 0, R_GetTexture(r_shadow_prepasslightingspeculartexture             ));
3107                 if (rsurface.rtlight)
3108                 {
3109                         if (r_glsl_permutation->loc_Texture_Cube            >= 0) R_Mesh_TexBindAll(GL20TU_CUBE           , 0, 0,    R_GetTexture(rsurface.rtlight->currentcubemap                    ), 0);
3110                         if (r_glsl_permutation->loc_Texture_ShadowMapRect   >= 0) R_Mesh_TexBindAll(GL20TU_SHADOWMAPRECT  , 0, 0, 0, R_GetTexture(r_shadow_shadowmaprectangletexture                  ));
3111                         if (r_shadow_usingshadowmapcube)
3112                                 if (r_glsl_permutation->loc_Texture_ShadowMapCube   >= 0) R_Mesh_TexBindAll(GL20TU_SHADOWMAPCUBE  , 0, 0,    R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]), 0);
3113                         if (r_glsl_permutation->loc_Texture_ShadowMap2D     >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAP2D       ,          R_GetTexture(r_shadow_shadowmap2dtexture                         ));
3114                         if (r_glsl_permutation->loc_Texture_CubeProjection  >= 0) R_Mesh_TexBindAll(GL20TU_CUBEPROJECTION , 0, 0,    R_GetTexture(r_shadow_shadowmapvsdcttexture                      ), 0);
3115                 }
3116                 CHECKGLERROR
3117                 break;
3118         case RENDERPATH_CGGL:
3119 #ifdef SUPPORTCG
3120                 R_SetupShader_SetPermutationCG(mode, permutation);
3121                 if (mode == SHADERMODE_LIGHTSOURCE)
3122                 {
3123                         if (r_cg_permutation->vp_ModelToLight) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelToLight, m16f);}CHECKCGERROR
3124                         if (r_cg_permutation->vp_LightPosition) cgGLSetParameter3f(r_cg_permutation->vp_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);CHECKCGERROR
3125                 }
3126                 else
3127                 {
3128                         if (mode == SHADERMODE_LIGHTDIRECTION)
3129                         {
3130                                 if (r_cg_permutation->vp_LightDir) cgGLSetParameter3f(r_cg_permutation->vp_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);CHECKCGERROR
3131                         }
3132                 }
3133                 if (r_cg_permutation->vp_ModelViewMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelviewprojection16f);CHECKCGERROR
3134                 if (r_cg_permutation->vp_TexMatrix) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_TexMatrix, m16f);}CHECKCGERROR
3135                 if (r_cg_permutation->vp_BackgroundTexMatrix) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_BackgroundTexMatrix, m16f);}CHECKCGERROR
3136                 if (r_cg_permutation->vp_EyePosition) cgGLSetParameter3f(r_cg_permutation->vp_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);CHECKCGERROR
3137                 if (r_cg_permutation->vp_FogPlane) cgGLSetParameter4f(r_cg_permutation->vp_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);CHECKCGERROR
3138                 CHECKGLERROR
3139
3140                 if (mode == SHADERMODE_LIGHTSOURCE)
3141                 {
3142                         if (r_cg_permutation->fp_LightPosition) cgGLSetParameter3f(r_cg_permutation->fp_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);CHECKCGERROR
3143                         if (r_cg_permutation->fp_LightColor) cgGLSetParameter3f(r_cg_permutation->fp_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);CHECKCGERROR
3144                         if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, rsurface.colormod[0] * ambientscale, rsurface.colormod[1] * ambientscale, rsurface.colormod[2] * ambientscale);CHECKCGERROR
3145                         if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, rsurface.colormod[0] * diffusescale, rsurface.colormod[1] * diffusescale, rsurface.colormod[2] * diffusescale);CHECKCGERROR
3146                         if (r_cg_permutation->fp_Color_Specular) cgGLSetParameter3f(r_cg_permutation->fp_Color_Specular, specularscale, specularscale, specularscale);CHECKCGERROR
3147
3148                         // additive passes are only darkened by fog, not tinted
3149                         if (r_cg_permutation->fp_FogColor) cgGLSetParameter3f(r_cg_permutation->fp_FogColor, 0, 0, 0);CHECKCGERROR
3150                         if (r_cg_permutation->fp_ShadowMap_TextureScale) cgGLSetParameter2f(r_cg_permutation->fp_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);CHECKCGERROR
3151                         if (r_cg_permutation->fp_ShadowMap_Parameters) cgGLSetParameter4f(r_cg_permutation->fp_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);CHECKCGERROR
3152                         if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR
3153                 }
3154                 else
3155                 {
3156                         if (mode == SHADERMODE_FLATCOLOR)
3157                         {
3158                                 if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, rsurface.colormod[0], rsurface.colormod[1], rsurface.colormod[2]);CHECKCGERROR
3159                         }
3160                         else if (mode == SHADERMODE_LIGHTDIRECTION)
3161                         {
3162                                 if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, (r_refdef.scene.ambient + rsurface.modellight_ambient[0] * r_refdef.lightmapintensity) * rsurface.colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity) * rsurface.colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity) * rsurface.colormod[2]);CHECKCGERROR
3163                                 if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, r_refdef.lightmapintensity, r_refdef.lightmapintensity, r_refdef.lightmapintensity);CHECKCGERROR
3164                                 if (r_cg_permutation->fp_Color_Specular) cgGLSetParameter3f(r_cg_permutation->fp_Color_Specular, r_refdef.lightmapintensity * specularscale, r_refdef.lightmapintensity * specularscale, r_refdef.lightmapintensity * specularscale);CHECKCGERROR
3165                                 if (r_cg_permutation->fp_DeferredMod_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Diffuse, rsurface.colormod[0] * r_shadow_deferred_8bitrange.value, rsurface.colormod[1] * r_shadow_deferred_8bitrange.value, rsurface.colormod[2] * r_shadow_deferred_8bitrange.value);CHECKCGERROR
3166                                 if (r_cg_permutation->fp_DeferredMod_Specular) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);CHECKCGERROR
3167                                 if (r_cg_permutation->fp_LightColor) cgGLSetParameter3f(r_cg_permutation->fp_LightColor, rsurface.modellight_diffuse[0], rsurface.modellight_diffuse[1], rsurface.modellight_diffuse[2]);CHECKCGERROR
3168                                 if (r_cg_permutation->fp_LightDir) cgGLSetParameter3f(r_cg_permutation->fp_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);CHECKCGERROR
3169                         }
3170                         else
3171                         {
3172                                 if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, r_refdef.scene.ambient * rsurface.colormod[0], r_refdef.scene.ambient * rsurface.colormod[1], r_refdef.scene.ambient * rsurface.colormod[2]);CHECKCGERROR
3173                                 if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, rsurface.texture->lightmapcolor[0], rsurface.texture->lightmapcolor[1], rsurface.texture->lightmapcolor[2]);CHECKCGERROR
3174                                 if (r_cg_permutation->fp_Color_Specular) cgGLSetParameter3f(r_cg_permutation->fp_Color_Specular, r_refdef.lightmapintensity * specularscale, r_refdef.lightmapintensity * specularscale, r_refdef.lightmapintensity * specularscale);CHECKCGERROR
3175                                 if (r_cg_permutation->fp_DeferredMod_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Diffuse, rsurface.colormod[0] * diffusescale * r_shadow_deferred_8bitrange.value, rsurface.colormod[1] * diffusescale * r_shadow_deferred_8bitrange.value, rsurface.colormod[2] * diffusescale * r_shadow_deferred_8bitrange.value);CHECKCGERROR
3176                                 if (r_cg_permutation->fp_DeferredMod_Specular) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);CHECKCGERROR
3177                         }
3178                         // additive passes are only darkened by fog, not tinted
3179                         if (r_cg_permutation->fp_FogColor)
3180                         {
3181                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
3182                                         cgGLSetParameter3f(r_cg_permutation->fp_FogColor, 0, 0, 0);
3183                                 else
3184                                         cgGLSetParameter3f(r_cg_permutation->fp_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
3185                                 CHECKCGERROR
3186                         }
3187                         if (r_cg_permutation->fp_DistortScaleRefractReflect) cgGLSetParameter4f(r_cg_permutation->fp_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);CHECKCGERROR
3188                         if (r_cg_permutation->fp_ScreenScaleRefractReflect) cgGLSetParameter4f(r_cg_permutation->fp_ScreenScaleRefractReflect, r_waterstate.screenscale[0], r_waterstate.screenscale[1], r_waterstate.screenscale[0], r_waterstate.screenscale[1]);CHECKCGERROR
3189                         if (r_cg_permutation->fp_ScreenCenterRefractReflect) cgGLSetParameter4f(r_cg_permutation->fp_ScreenCenterRefractReflect, r_waterstate.screencenter[0], r_waterstate.screencenter[1], r_waterstate.screencenter[0], r_waterstate.screencenter[1]);CHECKCGERROR
3190                         if (r_cg_permutation->fp_RefractColor) cgGLSetParameter4fv(r_cg_permutation->fp_RefractColor, rsurface.texture->refractcolor4f);CHECKCGERROR
3191                         if (r_cg_permutation->fp_ReflectColor) cgGLSetParameter4fv(r_cg_permutation->fp_ReflectColor, rsurface.texture->reflectcolor4f);CHECKCGERROR
3192                         if (r_cg_permutation->fp_ReflectFactor) cgGLSetParameter1f(r_cg_permutation->fp_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);CHECKCGERROR
3193                         if (r_cg_permutation->fp_ReflectOffset) cgGLSetParameter1f(r_cg_permutation->fp_ReflectOffset, rsurface.texture->reflectmin);CHECKCGERROR
3194                         if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR
3195                 }
3196                 if (r_cg_permutation->fp_Color_Glow) cgGLSetParameter3f(r_cg_permutation->fp_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);CHECKCGERROR
3197                 if (r_cg_permutation->fp_Alpha) cgGLSetParameter1f(r_cg_permutation->fp_Alpha, rsurface.texture->lightmapcolor[3]);CHECKCGERROR
3198                 if (r_cg_permutation->fp_EyePosition) cgGLSetParameter3f(r_cg_permutation->fp_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);CHECKCGERROR
3199                 if (r_cg_permutation->fp_Color_Pants)
3200                 {
3201                         if (rsurface.texture->pantstexture)
3202                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
3203                         else
3204                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Pants, 0, 0, 0);
3205                         CHECKCGERROR
3206                 }
3207                 if (r_cg_permutation->fp_Color_Shirt)
3208                 {
3209                         if (rsurface.texture->shirttexture)
3210                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
3211                         else
3212                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Shirt, 0, 0, 0);
3213                         CHECKCGERROR
3214                 }
3215                 if (r_cg_permutation->fp_FogPlane) cgGLSetParameter4f(r_cg_permutation->fp_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);CHECKCGERROR
3216                 if (r_cg_permutation->fp_FogPlaneViewDist) cgGLSetParameter1f(r_cg_permutation->fp_FogPlaneViewDist, rsurface.fogplaneviewdist);CHECKCGERROR
3217                 if (r_cg_permutation->fp_FogRangeRecip) cgGLSetParameter1f(r_cg_permutation->fp_FogRangeRecip, rsurface.fograngerecip);CHECKCGERROR
3218                 if (r_cg_permutation->fp_FogHeightFade) cgGLSetParameter1f(r_cg_permutation->fp_FogHeightFade, rsurface.fogheightfade);CHECKCGERROR
3219                 if (r_cg_permutation->fp_OffsetMapping_Scale) cgGLSetParameter1f(r_cg_permutation->fp_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);CHECKCGERROR
3220                 if (r_cg_permutation->fp_ScreenToDepth) cgGLSetParameter2f(r_cg_permutation->fp_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);CHECKCGERROR
3221
3222         //      if (r_cg_permutation->fp_Texture_First          ) CG_BindTexture(r_cg_permutation->fp_Texture_First          , R_GetTexture(r_texture_white                                     ));CHECKCGERROR
3223         //      if (r_cg_permutation->fp_Texture_Second         ) CG_BindTexture(r_cg_permutation->fp_Texture_Second         , R_GetTexture(r_texture_white                                     ));CHECKCGERROR
3224         //      if (r_cg_permutation->fp_Texture_GammaRamps     ) CG_BindTexture(r_cg_permutation->fp_Texture_GammaRamps     , R_GetTexture(r_texture_gammaramps                                ));CHECKCGERROR
3225                 if (r_cg_permutation->fp_Texture_Normal         ) CG_BindTexture(r_cg_permutation->fp_Texture_Normal         , R_GetTexture(rsurface.texture->nmaptexture                       ));CHECKCGERROR
3226                 if (r_cg_permutation->fp_Texture_Color          ) CG_BindTexture(r_cg_permutation->fp_Texture_Color          , R_GetTexture(rsurface.texture->basetexture                       ));CHECKCGERROR
3227                 if (r_cg_permutation->fp_Texture_Gloss          ) CG_BindTexture(r_cg_permutation->fp_Texture_Gloss          , R_GetTexture(rsurface.texture->glosstexture                      ));CHECKCGERROR
3228                 if (r_cg_permutation->fp_Texture_Glow           ) CG_BindTexture(r_cg_permutation->fp_Texture_Glow           , R_GetTexture(rsurface.texture->glowtexture                       ));CHECKCGERROR
3229                 if (r_cg_permutation->fp_Texture_SecondaryNormal) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryNormal, R_GetTexture(rsurface.texture->backgroundnmaptexture             ));CHECKCGERROR
3230                 if (r_cg_permutation->fp_Texture_SecondaryColor ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryColor , R_GetTexture(rsurface.texture->backgroundbasetexture             ));CHECKCGERROR
3231                 if (r_cg_permutation->fp_Texture_SecondaryGloss ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryGloss , R_GetTexture(rsurface.texture->backgroundglosstexture            ));CHECKCGERROR
3232                 if (r_cg_permutation->fp_Texture_SecondaryGlow  ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryGlow  , R_GetTexture(rsurface.texture->backgroundglowtexture             ));CHECKCGERROR
3233                 if (r_cg_permutation->fp_Texture_Pants          ) CG_BindTexture(r_cg_permutation->fp_Texture_Pants          , R_GetTexture(rsurface.texture->pantstexture                      ));CHECKCGERROR
3234                 if (r_cg_permutation->fp_Texture_Shirt          ) CG_BindTexture(r_cg_permutation->fp_Texture_Shirt          , R_GetTexture(rsurface.texture->shirttexture                      ));CHECKCGERROR
3235                 if (r_cg_permutation->fp_Texture_FogMask        ) CG_BindTexture(r_cg_permutation->fp_Texture_FogMask        , R_GetTexture(r_texture_fogattenuation                            ));CHECKCGERROR
3236                 if (r_cg_permutation->fp_Texture_Lightmap       ) CG_BindTexture(r_cg_permutation->fp_Texture_Lightmap       , R_GetTexture(r_texture_white                                     ));CHECKCGERROR
3237                 if (r_cg_permutation->fp_Texture_Deluxemap      ) CG_BindTexture(r_cg_permutation->fp_Texture_Deluxemap      , R_GetTexture(r_texture_blanknormalmap                            ));CHECKCGERROR
3238                 if (r_cg_permutation->fp_Texture_Attenuation    ) CG_BindTexture(r_cg_permutation->fp_Texture_Attenuation    , R_GetTexture(r_shadow_attenuationgradienttexture                 ));CHECKCGERROR
3239                 if (r_cg_permutation->fp_Texture_Refraction     ) CG_BindTexture(r_cg_permutation->fp_Texture_Refraction     , R_GetTexture(r_texture_white                                     ));CHECKCGERROR
3240                 if (r_cg_permutation->fp_Texture_Reflection     ) CG_BindTexture(r_cg_permutation->fp_Texture_Reflection     , R_GetTexture(r_texture_white                                     ));CHECKCGERROR
3241                 if (r_cg_permutation->fp_Texture_ScreenDepth    ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDepth    , R_GetTexture(r_shadow_prepassgeometrydepthtexture                ));CHECKCGERROR
3242                 if (r_cg_permutation->fp_Texture_ScreenNormalMap) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenNormalMap, R_GetTexture(r_shadow_prepassgeometrynormalmaptexture            ));CHECKCGERROR
3243                 if (r_cg_permutation->fp_Texture_ScreenDiffuse  ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDiffuse  , R_GetTexture(r_shadow_prepasslightingdiffusetexture              ));CHECKCGERROR
3244                 if (r_cg_permutation->fp_Texture_ScreenSpecular ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenSpecular , R_GetTexture(r_shadow_prepasslightingspeculartexture             ));CHECKCGERROR
3245                 if (rsurface.rtlight)
3246                 {
3247                         if (r_cg_permutation->fp_Texture_Cube       ) CG_BindTexture(r_cg_permutation->fp_Texture_Cube           , R_GetTexture(rsurface.rtlight->currentcubemap                    ));CHECKCGERROR
3248                         if (r_cg_permutation->fp_Texture_ShadowMapRect  ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapRect  , R_GetTexture(r_shadow_shadowmaprectangletexture                  ));CHECKCGERROR
3249                         if (r_shadow_usingshadowmapcube)
3250                                 if (r_cg_permutation->fp_Texture_ShadowMapCube  ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapCube  , R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]));CHECKCGERROR
3251                         if (r_cg_permutation->fp_Texture_ShadowMap2D    ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMap2D    , R_GetTexture(r_shadow_shadowmap2dtexture                         ));CHECKCGERROR
3252                         if (r_cg_permutation->fp_Texture_CubeProjection ) CG_BindTexture(r_cg_permutation->fp_Texture_CubeProjection , R_GetTexture(r_shadow_shadowmapvsdcttexture                      ));CHECKCGERROR
3253                 }
3254
3255                 CHECKGLERROR
3256 #endif
3257                 break;
3258         case RENDERPATH_GL13:
3259         case RENDERPATH_GL11:
3260                 break;
3261         }
3262 }
3263
3264 void R_SetupShader_DeferredLight(const rtlight_t *rtlight)
3265 {
3266         // select a permutation of the lighting shader appropriate to this
3267         // combination of texture, entity, light source, and fogging, only use the
3268         // minimum features necessary to avoid wasting rendering time in the
3269         // fragment shader on features that are not being used
3270         unsigned int permutation = 0;
3271         unsigned int mode = 0;
3272         const float *lightcolorbase = rtlight->currentcolor;
3273         float ambientscale = rtlight->ambientscale;
3274         float diffusescale = rtlight->diffusescale;
3275         float specularscale = rtlight->specularscale;
3276         // this is the location of the light in view space
3277         vec3_t viewlightorigin;
3278         // this transforms from view space (camera) to light space (cubemap)
3279         matrix4x4_t viewtolight;
3280         matrix4x4_t lighttoview;
3281         float viewtolight16f[16];
3282         float range = 1.0f / r_shadow_deferred_8bitrange.value;
3283         // light source
3284         mode = SHADERMODE_DEFERREDLIGHTSOURCE;
3285         if (rtlight->currentcubemap != r_texture_whitecube)
3286                 permutation |= SHADERPERMUTATION_CUBEFILTER;
3287         if (diffusescale > 0)
3288                 permutation |= SHADERPERMUTATION_DIFFUSE;
3289         if (specularscale > 0)
3290         {
3291                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
3292                 if (r_shadow_glossexact.integer)
3293                         permutation |= SHADERPERMUTATION_EXACTSPECULARMATH;
3294         }
3295         if (r_shadow_usingshadowmaprect || r_shadow_usingshadowmap2d || r_shadow_usingshadowmapcube)
3296         {
3297                 if (r_shadow_usingshadowmaprect)
3298                         permutation |= SHADERPERMUTATION_SHADOWMAPRECT;
3299                 if (r_shadow_usingshadowmap2d)
3300                         permutation |= SHADERPERMUTATION_SHADOWMAP2D;
3301                 if (r_shadow_usingshadowmapcube)
3302                         permutation |= SHADERPERMUTATION_SHADOWMAPCUBE;
3303                 else if(r_shadow_shadowmapvsdct)
3304                         permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT;
3305
3306                 if (r_shadow_shadowmapsampler)
3307                         permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
3308                 if (r_shadow_shadowmappcf > 1)
3309                         permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
3310                 else if (r_shadow_shadowmappcf)
3311                         permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
3312         }
3313         Matrix4x4_Transform(&r_refdef.view.viewport.viewmatrix, rtlight->shadoworigin, viewlightorigin);
3314         Matrix4x4_Concat(&lighttoview, &r_refdef.view.viewport.viewmatrix, &rtlight->matrix_lighttoworld);
3315         Matrix4x4_Invert_Simple(&viewtolight, &lighttoview);
3316         Matrix4x4_ToArrayFloatGL(&viewtolight, viewtolight16f);
3317         switch(vid.renderpath)
3318         {
3319         case RENDERPATH_GL20:
3320                 R_SetupShader_SetPermutationGLSL(mode, permutation);
3321                 if (r_glsl_permutation->loc_ModelViewMatrix           >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewMatrix          , 1, false, gl_modelview16f);
3322                 if (r_glsl_permutation->loc_LightPosition             >= 0) qglUniform3fARB(       r_glsl_permutation->loc_LightPosition            , viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);
3323                 if (r_glsl_permutation->loc_ViewToLight               >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ViewToLight              , 1, false, viewtolight16f);
3324                 if (r_glsl_permutation->loc_DeferredColor_Ambient     >= 0) qglUniform3fARB(       r_glsl_permutation->loc_DeferredColor_Ambient    , lightcolorbase[0] * ambientscale  * range, lightcolorbase[1] * ambientscale  * range, lightcolorbase[2] * ambientscale  * range);
3325                 if (r_glsl_permutation->loc_DeferredColor_Diffuse     >= 0) qglUniform3fARB(       r_glsl_permutation->loc_DeferredColor_Diffuse    , lightcolorbase[0] * diffusescale  * range, lightcolorbase[1] * diffusescale  * range, lightcolorbase[2] * diffusescale  * range);
3326                 if (r_glsl_permutation->loc_DeferredColor_Specular    >= 0) qglUniform3fARB(       r_glsl_permutation->loc_DeferredColor_Specular   , lightcolorbase[0] * specularscale * range, lightcolorbase[1] * specularscale * range, lightcolorbase[2] * specularscale * range);
3327                 if (r_glsl_permutation->loc_ShadowMap_TextureScale    >= 0) qglUniform2fARB(       r_glsl_permutation->loc_ShadowMap_TextureScale   , r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);
3328                 if (r_glsl_permutation->loc_ShadowMap_Parameters      >= 0) qglUniform4fARB(       r_glsl_permutation->loc_ShadowMap_Parameters     , r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);
3329                 if (r_glsl_permutation->loc_SpecularPower             >= 0) qglUniform1fARB(       r_glsl_permutation->loc_SpecularPower            , (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));
3330                 if (r_glsl_permutation->loc_ScreenToDepth             >= 0) qglUniform2fARB(       r_glsl_permutation->loc_ScreenToDepth            , r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
3331
3332                 if (r_glsl_permutation->loc_Texture_Attenuation       >= 0) R_Mesh_TexBind(GL20TU_ATTENUATION       ,          R_GetTexture(r_shadow_attenuationgradienttexture                 ));
3333                 if (r_glsl_permutation->loc_Texture_ScreenDepth       >= 0) R_Mesh_TexBindAll(GL20TU_SCREENDEPTH    , 0, 0, 0, R_GetTexture(r_shadow_prepassgeometrydepthtexture                ));
3334                 if (r_glsl_permutation->loc_Texture_ScreenNormalMap   >= 0) R_Mesh_TexBindAll(GL20TU_SCREENNORMALMAP, 0, 0, 0, R_GetTexture(r_shadow_prepassgeometrynormalmaptexture            ));
3335                 if (r_glsl_permutation->loc_Texture_Cube              >= 0) R_Mesh_TexBindAll(GL20TU_CUBE           , 0, 0,    R_GetTexture(rsurface.rtlight->currentcubemap                    ), 0);
3336                 if (r_glsl_permutation->loc_Texture_ShadowMapRect     >= 0) R_Mesh_TexBindAll(GL20TU_SHADOWMAPRECT  , 0, 0, 0, R_GetTexture(r_shadow_shadowmaprectangletexture                  ));
3337                 if (r_shadow_usingshadowmapcube)
3338                         if (r_glsl_permutation->loc_Texture_ShadowMapCube     >= 0) R_Mesh_TexBindAll(GL20TU_SHADOWMAPCUBE  , 0, 0,    R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]), 0);
3339                 if (r_glsl_permutation->loc_Texture_ShadowMap2D       >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAP2D       ,          R_GetTexture(r_shadow_shadowmap2dtexture                         ));
3340                 if (r_glsl_permutation->loc_Texture_CubeProjection    >= 0) R_Mesh_TexBindAll(GL20TU_CUBEPROJECTION , 0, 0,    R_GetTexture(r_shadow_shadowmapvsdcttexture                      ), 0);
3341                 break;
3342         case RENDERPATH_CGGL:
3343 #ifdef SUPPORTCG
3344                 R_SetupShader_SetPermutationCG(mode, permutation);
3345                 if (r_cg_permutation->vp_ModelViewMatrix          ) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelviewprojection16f);CHECKCGERROR
3346                 if (r_cg_permutation->fp_LightPosition            ) cgGLSetParameter3f(r_cg_permutation->fp_LightPosition, viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);CHECKCGERROR
3347                 if (r_cg_permutation->fp_ViewToLight              ) cgGLSetMatrixParameterfc(r_cg_permutation->fp_ViewToLight, viewtolight16f);CHECKCGERROR
3348                 if (r_cg_permutation->fp_DeferredColor_Ambient    ) cgGLSetParameter3f(r_cg_permutation->fp_DeferredColor_Ambient , lightcolorbase[0] * ambientscale  * range, lightcolorbase[1] * ambientscale  * range, lightcolorbase[2] * ambientscale  * range);CHECKCGERROR
3349                 if (r_cg_permutation->fp_DeferredColor_Diffuse    ) cgGLSetParameter3f(r_cg_permutation->fp_DeferredColor_Diffuse , lightcolorbase[0] * diffusescale  * range, lightcolorbase[1] * diffusescale  * range, lightcolorbase[2] * diffusescale  * range);CHECKCGERROR
3350                 if (r_cg_permutation->fp_DeferredColor_Specular   ) cgGLSetParameter3f(r_cg_permutation->fp_DeferredColor_Specular, lightcolorbase[0] * specularscale * range, lightcolorbase[1] * specularscale * range, lightcolorbase[2] * specularscale * range);CHECKCGERROR
3351                 if (r_cg_permutation->fp_ShadowMap_TextureScale   ) cgGLSetParameter2f(r_cg_permutation->fp_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);CHECKCGERROR
3352                 if (r_cg_permutation->fp_ShadowMap_Parameters     ) cgGLSetParameter4f(r_cg_permutation->fp_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);CHECKCGERROR
3353                 if (r_cg_permutation->fp_SpecularPower            ) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR
3354                 if (r_cg_permutation->fp_ScreenToDepth            ) cgGLSetParameter2f(r_cg_permutation->fp_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);CHECKCGERROR
3355
3356                 if (r_cg_permutation->fp_Texture_Attenuation      ) CG_BindTexture(r_cg_permutation->fp_Texture_Attenuation    , R_GetTexture(r_shadow_attenuationgradienttexture                 ));CHECKCGERROR
3357                 if (r_cg_permutation->fp_Texture_ScreenDepth      ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDepth    , R_GetTexture(r_shadow_prepassgeometrydepthtexture                ));CHECKCGERROR
3358                 if (r_cg_permutation->fp_Texture_ScreenNormalMap  ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenNormalMap, R_GetTexture(r_shadow_prepassgeometrynormalmaptexture            ));CHECKCGERROR
3359                 if (r_cg_permutation->fp_Texture_Cube             ) CG_BindTexture(r_cg_permutation->fp_Texture_Cube           , R_GetTexture(rsurface.rtlight->currentcubemap                    ));CHECKCGERROR
3360                 if (r_cg_permutation->fp_Texture_ShadowMapRect    ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapRect  , R_GetTexture(r_shadow_shadowmaprectangletexture                  ));CHECKCGERROR
3361                 if (r_shadow_usingshadowmapcube)
3362                         if (r_cg_permutation->fp_Texture_ShadowMapCube    ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapCube  , R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]));CHECKCGERROR
3363                 if (r_cg_permutation->fp_Texture_ShadowMap2D      ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMap2D    , R_GetTexture(r_shadow_shadowmap2dtexture                         ));CHECKCGERROR
3364                 if (r_cg_permutation->fp_Texture_CubeProjection   ) CG_BindTexture(r_cg_permutation->fp_Texture_CubeProjection , R_GetTexture(r_shadow_shadowmapvsdcttexture                      ));CHECKCGERROR
3365 #endif
3366                 break;
3367         case RENDERPATH_GL13:
3368         case RENDERPATH_GL11:
3369                 break;
3370         }
3371 }
3372
3373 #define SKINFRAME_HASH 1024
3374
3375 typedef struct
3376 {
3377         int loadsequence; // incremented each level change
3378         memexpandablearray_t array;
3379         skinframe_t *hash[SKINFRAME_HASH];
3380 }
3381 r_skinframe_t;
3382 r_skinframe_t r_skinframe;
3383
3384 void R_SkinFrame_PrepareForPurge(void)
3385 {
3386         r_skinframe.loadsequence++;
3387         // wrap it without hitting zero
3388         if (r_skinframe.loadsequence >= 200)
3389                 r_skinframe.loadsequence = 1;
3390 }
3391
3392 void R_SkinFrame_MarkUsed(skinframe_t *skinframe)
3393 {
3394         if (!skinframe)
3395                 return;
3396         // mark the skinframe as used for the purging code
3397         skinframe->loadsequence = r_skinframe.loadsequence;
3398 }
3399
3400 void R_SkinFrame_Purge(void)
3401 {
3402         int i;
3403         skinframe_t *s;
3404         for (i = 0;i < SKINFRAME_HASH;i++)
3405         {
3406                 for (s = r_skinframe.hash[i];s;s = s->next)
3407                 {
3408                         if (s->loadsequence && s->loadsequence != r_skinframe.loadsequence)
3409                         {
3410                                 if (s->merged == s->base)
3411                                         s->merged = NULL;
3412                                 // FIXME: maybe pass a pointer to the pointer to R_PurgeTexture and reset it to NULL inside? [11/29/2007 Black]
3413                                 R_PurgeTexture(s->stain );s->stain  = NULL;
3414                                 R_PurgeTexture(s->merged);s->merged = NULL;
3415                                 R_PurgeTexture(s->base  );s->base   = NULL;
3416                                 R_PurgeTexture(s->pants );s->pants  = NULL;
3417                                 R_PurgeTexture(s->shirt );s->shirt  = NULL;
3418                                 R_PurgeTexture(s->nmap  );s->nmap   = NULL;
3419                                 R_PurgeTexture(s->gloss );s->gloss  = NULL;
3420                                 R_PurgeTexture(s->glow  );s->glow   = NULL;
3421                                 R_PurgeTexture(s->fog   );s->fog    = NULL;
3422                                 s->loadsequence = 0;
3423                         }
3424                 }
3425         }
3426 }
3427
3428 skinframe_t *R_SkinFrame_FindNextByName( skinframe_t *last, const char *name ) {
3429         skinframe_t *item;
3430         char basename[MAX_QPATH];
3431
3432         Image_StripImageExtension(name, basename, sizeof(basename));
3433
3434         if( last == NULL ) {
3435                 int hashindex;
3436                 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
3437                 item = r_skinframe.hash[hashindex];
3438         } else {
3439                 item = last->next;
3440         }
3441
3442         // linearly search through the hash bucket
3443         for( ; item ; item = item->next ) {
3444                 if( !strcmp( item->basename, basename ) ) {
3445                         return item;
3446                 }
3447         }
3448         return NULL;
3449 }
3450
3451 skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qboolean add)
3452 {
3453         skinframe_t *item;
3454         int hashindex;
3455         char basename[MAX_QPATH];
3456
3457         Image_StripImageExtension(name, basename, sizeof(basename));
3458
3459         hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
3460         for (item = r_skinframe.hash[hashindex];item;item = item->next)
3461                 if (!strcmp(item->basename, basename) && item->textureflags == textureflags && item->comparewidth == comparewidth && item->compareheight == compareheight && item->comparecrc == comparecrc)
3462                         break;
3463
3464         if (!item) {
3465                 rtexture_t *dyntexture;
3466                 // check whether its a dynamic texture
3467                 dyntexture = CL_GetDynTexture( basename );
3468                 if (!add && !dyntexture)
3469                         return NULL;
3470                 item = (skinframe_t *)Mem_ExpandableArray_AllocRecord(&r_skinframe.array);
3471                 memset(item, 0, sizeof(*item));
3472                 strlcpy(item->basename, basename, sizeof(item->basename));
3473                 item->base = dyntexture; // either NULL or dyntexture handle
3474                 item->textureflags = textureflags;
3475                 item->comparewidth = comparewidth;
3476                 item->compareheight = compareheight;
3477                 item->comparecrc = comparecrc;
3478                 item->next = r_skinframe.hash[hashindex];
3479                 r_skinframe.hash[hashindex] = item;
3480         }
3481         else if( item->base == NULL )
3482         {
3483                 rtexture_t *dyntexture;
3484                 // check whether its a dynamic texture
3485                 // 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]
3486                 dyntexture = CL_GetDynTexture( basename );
3487                 item->base = dyntexture; // either NULL or dyntexture handle
3488         }
3489
3490         R_SkinFrame_MarkUsed(item);
3491         return item;
3492 }
3493
3494 #define R_SKINFRAME_LOAD_AVERAGE_COLORS(cnt, getpixel) \
3495         { \
3496                 unsigned long long avgcolor[5], wsum; \
3497                 int pix, comp, w; \
3498                 avgcolor[0] = 0; \
3499                 avgcolor[1] = 0; \
3500                 avgcolor[2] = 0; \
3501                 avgcolor[3] = 0; \
3502                 avgcolor[4] = 0; \
3503                 wsum = 0; \
3504                 for(pix = 0; pix < cnt; ++pix) \
3505                 { \
3506                         w = 0; \
3507                         for(comp = 0; comp < 3; ++comp) \
3508                                 w += getpixel; \
3509                         if(w) /* ignore perfectly black pixels because that is better for model skins */ \
3510                         { \
3511                                 ++wsum; \
3512                                 /* comp = 3; -- not needed, comp is always 3 when we get here */ \
3513                                 w = getpixel; \
3514                                 for(comp = 0; comp < 3; ++comp) \
3515                                         avgcolor[comp] += getpixel * w; \
3516                                 avgcolor[3] += w; \
3517                         } \
3518                         /* comp = 3; -- not needed, comp is always 3 when we get here */ \
3519                         avgcolor[4] += getpixel; \
3520                 } \
3521                 if(avgcolor[3] == 0) /* no pixels seen? even worse */ \
3522                         avgcolor[3] = 1; \
3523                 skinframe->avgcolor[0] = avgcolor[2] / (255.0 * avgcolor[3]); \
3524                 skinframe->avgcolor[1] = avgcolor[1] / (255.0 * avgcolor[3]); \
3525                 skinframe->avgcolor[2] = avgcolor[0] / (255.0 * avgcolor[3]); \
3526                 skinframe->avgcolor[3] = avgcolor[4] / (255.0 * cnt); \
3527         }
3528
3529 skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain)
3530 {
3531         int j;
3532         unsigned char *pixels;
3533         unsigned char *bumppixels;
3534         unsigned char *basepixels = NULL;
3535         int basepixels_width;
3536         int basepixels_height;
3537         skinframe_t *skinframe;
3538
3539         if (cls.state == ca_dedicated)
3540                 return NULL;
3541
3542         // return an existing skinframe if already loaded
3543         // if loading of the first image fails, don't make a new skinframe as it
3544         // would cause all future lookups of this to be missing
3545         skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
3546         if (skinframe && skinframe->base)
3547                 return skinframe;
3548
3549         basepixels = loadimagepixelsbgra(name, complain, true);
3550         if (basepixels == NULL)
3551                 return NULL;
3552
3553         if (developer_loading.integer)
3554                 Con_Printf("loading skin \"%s\"\n", name);
3555
3556         // we've got some pixels to store, so really allocate this new texture now
3557         if (!skinframe)
3558                 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, true);
3559         skinframe->stain = NULL;
3560         skinframe->merged = NULL;
3561         skinframe->base = r_texture_notexture;
3562         skinframe->pants = NULL;
3563         skinframe->shirt = NULL;
3564         skinframe->nmap = r_texture_blanknormalmap;
3565         skinframe->gloss = NULL;
3566         skinframe->glow = NULL;
3567         skinframe->fog = NULL;
3568         skinframe->hasalpha = false;
3569
3570         basepixels_width = image_width;
3571         basepixels_height = image_height;
3572         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);
3573
3574         if (textureflags & TEXF_ALPHA)
3575         {
3576                 for (j = 3;j < basepixels_width * basepixels_height * 4;j += 4)
3577                 {
3578                         if (basepixels[j] < 255)
3579                         {
3580                                 skinframe->hasalpha = true;
3581                                 break;
3582                         }
3583                 }
3584                 if (r_loadfog && skinframe->hasalpha)
3585                 {
3586                         // has transparent pixels
3587                         pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
3588                         for (j = 0;j < image_width * image_height * 4;j += 4)
3589                         {
3590                                 pixels[j+0] = 255;
3591                                 pixels[j+1] = 255;
3592                                 pixels[j+2] = 255;
3593                                 pixels[j+3] = basepixels[j+3];
3594                         }
3595                         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);
3596                         Mem_Free(pixels);
3597                 }
3598         }
3599
3600         R_SKINFRAME_LOAD_AVERAGE_COLORS(basepixels_width * basepixels_height, basepixels[4 * pix + comp]);
3601         //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
3602
3603         // _norm is the name used by tenebrae and has been adopted as standard
3604         if (r_loadnormalmap)
3605         {
3606                 if ((pixels = loadimagepixelsbgra(va("%s_norm", skinframe->basename), false, false)) != NULL)
3607                 {
3608                         skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | skinframe->textureflags) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
3609                         Mem_Free(pixels);
3610                         pixels = NULL;
3611                 }
3612                 else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixelsbgra(va("%s_bump", skinframe->basename), false, false)) != NULL)
3613                 {
3614                         pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
3615                         Image_HeightmapToNormalmap_BGRA(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value);
3616                         skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | skinframe->textureflags) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
3617                         Mem_Free(pixels);
3618                         Mem_Free(bumppixels);
3619                 }
3620                 else if (r_shadow_bumpscale_basetexture.value > 0)
3621                 {
3622                         pixels = (unsigned char *)Mem_Alloc(tempmempool, basepixels_width * basepixels_height * 4);
3623                         Image_HeightmapToNormalmap_BGRA(basepixels, pixels, basepixels_width, basepixels_height, false, r_shadow_bumpscale_basetexture.value);
3624                         skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), basepixels_width, basepixels_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | skinframe->textureflags) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
3625                         Mem_Free(pixels);
3626                 }
3627         }
3628         // _luma is supported for tenebrae compatibility
3629         // (I think it's a very stupid name, but oh well)
3630         // _glow is the preferred name
3631         if ((pixels = loadimagepixelsbgra(va("%s_glow",  skinframe->basename), false, false)) || (pixels = loadimagepixelsbgra(va("%s_luma", skinframe->basename), false, false))) {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;}
3632         if (r_loadgloss && (pixels = loadimagepixelsbgra(va("%s_gloss", skinframe->basename), false, false))) {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;}
3633         if ((pixels = loadimagepixelsbgra(va("%s_pants", skinframe->basename), false, false))) {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;}
3634         if ((pixels = loadimagepixelsbgra(va("%s_shirt", skinframe->basename), false, false))) {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;}
3635
3636         if (basepixels)
3637                 Mem_Free(basepixels);
3638
3639         return skinframe;
3640 }
3641
3642 // this is only used by .spr32 sprites, HL .spr files, HL .bsp files
3643 skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, const unsigned char *skindata, int width, int height)
3644 {
3645         int i;
3646         unsigned char *temp1, *temp2;
3647         skinframe_t *skinframe;
3648
3649         if (cls.state == ca_dedicated)
3650                 return NULL;
3651
3652         // if already loaded just return it, otherwise make a new skinframe
3653         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height*4) : 0, true);
3654         if (skinframe && skinframe->base)
3655                 return skinframe;
3656
3657         skinframe->stain = NULL;
3658         skinframe->merged = NULL;
3659         skinframe->base = r_texture_notexture;
3660         skinframe->pants = NULL;
3661         skinframe->shirt = NULL;
3662         skinframe->nmap = r_texture_blanknormalmap;
3663         skinframe->gloss = NULL;
3664         skinframe->glow = NULL;
3665         skinframe->fog = NULL;
3666         skinframe->hasalpha = false;
3667
3668         // if no data was provided, then clearly the caller wanted to get a blank skinframe
3669         if (!skindata)
3670                 return NULL;
3671
3672         if (developer_loading.integer)
3673                 Con_Printf("loading 32bit skin \"%s\"\n", name);
3674
3675         if (r_loadnormalmap && r_shadow_bumpscale_basetexture.value > 0)
3676         {
3677                 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
3678                 temp2 = temp1 + width * height * 4;
3679                 Image_HeightmapToNormalmap_BGRA(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
3680                 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, NULL);
3681                 Mem_Free(temp1);
3682         }
3683         skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_BGRA, skinframe->textureflags, NULL);
3684         if (textureflags & TEXF_ALPHA)
3685         {
3686                 for (i = 3;i < width * height * 4;i += 4)
3687                 {
3688                         if (skindata[i] < 255)
3689                         {
3690                                 skinframe->hasalpha = true;
3691                                 break;
3692                         }
3693                 }
3694                 if (r_loadfog && skinframe->hasalpha)
3695                 {
3696                         unsigned char *fogpixels = (unsigned char *)Mem_Alloc(tempmempool, width * height * 4);
3697                         memcpy(fogpixels, skindata, width * height * 4);
3698                         for (i = 0;i < width * height * 4;i += 4)
3699                                 fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
3700                         skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_BGRA, skinframe->textureflags, NULL);
3701                         Mem_Free(fogpixels);
3702                 }
3703         }
3704
3705         R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, skindata[4 * pix + comp]);
3706         //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
3707
3708         return skinframe;
3709 }
3710
3711 skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height)
3712 {
3713         int i;
3714         int featuresmask;
3715         skinframe_t *skinframe;
3716
3717         if (cls.state == ca_dedicated)
3718                 return NULL;
3719
3720         // if already loaded just return it, otherwise make a new skinframe
3721         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
3722         if (skinframe && skinframe->base)
3723                 return skinframe;
3724
3725         skinframe->stain = NULL;
3726         skinframe->merged = NULL;
3727         skinframe->base = r_texture_notexture;
3728         skinframe->pants = NULL;
3729         skinframe->shirt = NULL;
3730         skinframe->nmap = r_texture_blanknormalmap;
3731         skinframe->gloss = NULL;
3732         skinframe->glow = NULL;
3733         skinframe->fog = NULL;
3734         skinframe->hasalpha = false;
3735
3736         // if no data was provided, then clearly the caller wanted to get a blank skinframe
3737         if (!skindata)
3738                 return NULL;
3739
3740         if (developer_loading.integer)
3741                 Con_Printf("loading quake skin \"%s\"\n", name);
3742
3743         // we actually don't upload anything until the first use, because mdl skins frequently go unused, and are almost never used in both modes (colormapped and non-colormapped)
3744         skinframe->qpixels = Mem_Alloc(r_main_mempool, width*height);
3745         memcpy(skinframe->qpixels, skindata, width*height);
3746         skinframe->qwidth = width;
3747         skinframe->qheight = height;
3748
3749         featuresmask = 0;
3750         for (i = 0;i < width * height;i++)
3751                 featuresmask |= palette_featureflags[skindata[i]];
3752
3753         skinframe->hasalpha = false;
3754         skinframe->qhascolormapping = loadpantsandshirt && (featuresmask & (PALETTEFEATURE_PANTS | PALETTEFEATURE_SHIRT));
3755         skinframe->qgeneratenmap = r_shadow_bumpscale_basetexture.value > 0;
3756         skinframe->qgeneratemerged = true;
3757         skinframe->qgeneratebase = skinframe->qhascolormapping;
3758         skinframe->qgenerateglow = loadglowtexture && (featuresmask & PALETTEFEATURE_GLOW);
3759
3760         R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette_bgra_complete)[skindata[pix]*4 + comp]);
3761         //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
3762
3763         return skinframe;
3764 }
3765
3766 static void R_SkinFrame_GenerateTexturesFromQPixels(skinframe_t *skinframe, qboolean colormapped)
3767 {
3768         int width;
3769         int height;
3770         unsigned char *skindata;
3771
3772         if (!skinframe->qpixels)
3773                 return;
3774
3775         if (!skinframe->qhascolormapping)
3776                 colormapped = false;
3777
3778         if (colormapped)
3779         {
3780                 if (!skinframe->qgeneratebase)
3781                         return;
3782         }
3783         else
3784         {
3785                 if (!skinframe->qgeneratemerged)
3786                         return;
3787         }
3788
3789         width = skinframe->qwidth;
3790         height = skinframe->qheight;
3791         skindata = skinframe->qpixels;
3792
3793         if (skinframe->qgeneratenmap)
3794         {
3795                 unsigned char *temp1, *temp2;
3796                 skinframe->qgeneratenmap = false;
3797                 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
3798                 temp2 = temp1 + width * height * 4;
3799                 // use either a custom palette or the quake palette
3800                 Image_Copy8bitBGRA(skindata, temp1, width * height, palette_bgra_complete);
3801                 Image_HeightmapToNormalmap_BGRA(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
3802                 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, NULL);
3803                 Mem_Free(temp1);
3804         }
3805
3806         if (skinframe->qgenerateglow)
3807         {
3808                 skinframe->qgenerateglow = false;
3809                 skinframe->glow = R_LoadTexture2D(r_main_texturepool, va("%s_glow", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, palette_bgra_onlyfullbrights); // glow
3810         }
3811
3812         if (colormapped)
3813         {
3814                 skinframe->qgeneratebase = false;
3815                 skinframe->base  = R_LoadTexture2D(r_main_texturepool, va("%s_nospecial", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, skinframe->glow ? palette_bgra_nocolormapnofullbrights : palette_bgra_nocolormap);
3816                 skinframe->pants = R_LoadTexture2D(r_main_texturepool, va("%s_pants", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, palette_bgra_pantsaswhite);
3817                 skinframe->shirt = R_LoadTexture2D(r_main_texturepool, va("%s_shirt", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, palette_bgra_shirtaswhite);
3818         }
3819         else
3820         {
3821                 skinframe->qgeneratemerged = false;
3822                 skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, skinframe->glow ? palette_bgra_nofullbrights : palette_bgra_complete);
3823         }
3824
3825         if (!skinframe->qgeneratemerged && !skinframe->qgeneratebase)
3826         {
3827                 Mem_Free(skinframe->qpixels);
3828                 skinframe->qpixels = NULL;
3829         }
3830 }
3831
3832 skinframe_t *R_SkinFrame_LoadInternal8bit(const char *name, int textureflags, const unsigned char *skindata, int width, int height, const unsigned int *palette, const unsigned int *alphapalette)
3833 {
3834         int i;
3835         skinframe_t *skinframe;
3836
3837         if (cls.state == ca_dedicated)
3838                 return NULL;
3839
3840         // if already loaded just return it, otherwise make a new skinframe
3841         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
3842         if (skinframe && skinframe->base)
3843                 return skinframe;
3844
3845         skinframe->stain = NULL;
3846         skinframe->merged = NULL;
3847         skinframe->base = r_texture_notexture;
3848         skinframe->pants = NULL;
3849         skinframe->shirt = NULL;
3850         skinframe->nmap = r_texture_blanknormalmap;
3851         skinframe->gloss = NULL;
3852         skinframe->glow = NULL;
3853         skinframe->fog = NULL;
3854         skinframe->hasalpha = false;
3855
3856         // if no data was provided, then clearly the caller wanted to get a blank skinframe
3857         if (!skindata)
3858                 return NULL;
3859
3860         if (developer_loading.integer)
3861                 Con_Printf("loading embedded 8bit image \"%s\"\n", name);
3862
3863         skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, palette);
3864         if (textureflags & TEXF_ALPHA)
3865         {
3866                 for (i = 0;i < width * height;i++)
3867                 {
3868                         if (((unsigned char *)palette)[skindata[i]*4+3] < 255)
3869                         {
3870                                 skinframe->hasalpha = true;
3871                                 break;
3872                         }
3873                 }
3874                 if (r_loadfog && skinframe->hasalpha)
3875                         skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, alphapalette);
3876         }
3877
3878         R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette)[skindata[pix]*4 + comp]);
3879         //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
3880
3881         return skinframe;
3882 }
3883
3884 skinframe_t *R_SkinFrame_LoadMissing(void)
3885 {
3886         skinframe_t *skinframe;
3887
3888         if (cls.state == ca_dedicated)
3889                 return NULL;
3890
3891         skinframe = R_SkinFrame_Find("missing", TEXF_FORCENEAREST, 0, 0, 0, true);
3892         skinframe->stain = NULL;
3893         skinframe->merged = NULL;
3894         skinframe->base = r_texture_notexture;
3895         skinframe->pants = NULL;
3896         skinframe->shirt = NULL;
3897         skinframe->nmap = r_texture_blanknormalmap;
3898         skinframe->gloss = NULL;
3899         skinframe->glow = NULL;
3900         skinframe->fog = NULL;
3901         skinframe->hasalpha = false;
3902
3903         skinframe->avgcolor[0] = rand() / RAND_MAX;
3904         skinframe->avgcolor[1] = rand() / RAND_MAX;
3905         skinframe->avgcolor[2] = rand() / RAND_MAX;
3906         skinframe->avgcolor[3] = 1;
3907
3908         return skinframe;
3909 }
3910
3911 void R_Main_FreeViewCache(void)
3912 {
3913         if (r_refdef.viewcache.entityvisible)
3914                 Mem_Free(r_refdef.viewcache.entityvisible);
3915         if (r_refdef.viewcache.world_pvsbits)
3916                 Mem_Free(r_refdef.viewcache.world_pvsbits);
3917         if (r_refdef.viewcache.world_leafvisible)
3918                 Mem_Free(r_refdef.viewcache.world_leafvisible);
3919         if (r_refdef.viewcache.world_surfacevisible)
3920                 Mem_Free(r_refdef.viewcache.world_surfacevisible);
3921         memset(&r_refdef.viewcache, 0, sizeof(r_refdef.viewcache));
3922 }
3923
3924 void R_Main_ResizeViewCache(void)
3925 {
3926         int numentities = r_refdef.scene.numentities;
3927         int numclusters = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_pvsclusters : 1;
3928         int numclusterbytes = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_pvsclusterbytes : 1;
3929         int numleafs = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_leafs : 1;
3930         int numsurfaces = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->num_surfaces : 1;
3931         if (r_refdef.viewcache.maxentities < numentities)
3932         {
3933                 r_refdef.viewcache.maxentities = numentities;
3934                 if (r_refdef.viewcache.entityvisible)
3935                         Mem_Free(r_refdef.viewcache.entityvisible);
3936                 r_refdef.viewcache.entityvisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.maxentities);
3937         }
3938         if (r_refdef.viewcache.world_numclusters != numclusters)
3939         {
3940                 r_refdef.viewcache.world_numclusters = numclusters;
3941                 r_refdef.viewcache.world_numclusterbytes = numclusterbytes;
3942                 if (r_refdef.viewcache.world_pvsbits)
3943                         Mem_Free(r_refdef.viewcache.world_pvsbits);
3944                 r_refdef.viewcache.world_pvsbits = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numclusterbytes);
3945         }
3946         if (r_refdef.viewcache.world_numleafs != numleafs)
3947         {
3948                 r_refdef.viewcache.world_numleafs = numleafs;
3949                 if (r_refdef.viewcache.world_leafvisible)
3950                         Mem_Free(r_refdef.viewcache.world_leafvisible);
3951                 r_refdef.viewcache.world_leafvisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numleafs);
3952         }
3953         if (r_refdef.viewcache.world_numsurfaces != numsurfaces)
3954         {
3955                 r_refdef.viewcache.world_numsurfaces = numsurfaces;
3956                 if (r_refdef.viewcache.world_surfacevisible)
3957                         Mem_Free(r_refdef.viewcache.world_surfacevisible);
3958                 r_refdef.viewcache.world_surfacevisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numsurfaces);
3959         }
3960 }
3961
3962 extern rtexture_t *loadingscreentexture;
3963 void gl_main_start(void)
3964 {
3965         loadingscreentexture = NULL;
3966         r_texture_blanknormalmap = NULL;
3967         r_texture_white = NULL;
3968         r_texture_grey128 = NULL;
3969         r_texture_black = NULL;
3970         r_texture_whitecube = NULL;
3971         r_texture_normalizationcube = NULL;
3972         r_texture_fogattenuation = NULL;
3973         r_texture_gammaramps = NULL;
3974
3975         switch(vid.renderpath)
3976         {
3977         case RENDERPATH_GL20:
3978         case RENDERPATH_CGGL:
3979                 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
3980                 Cvar_SetValueQuick(&gl_combine, 1);
3981                 Cvar_SetValueQuick(&r_glsl, 1);
3982                 r_loadnormalmap = true;
3983                 r_loadgloss = true;
3984                 r_loadfog = false;
3985                 break;
3986         case RENDERPATH_GL13:
3987                 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
3988                 Cvar_SetValueQuick(&gl_combine, 1);
3989                 Cvar_SetValueQuick(&r_glsl, 0);
3990                 r_loadnormalmap = false;
3991                 r_loadgloss = false;
3992                 r_loadfog = true;
3993                 break;
3994         case RENDERPATH_GL11:
3995                 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
3996                 Cvar_SetValueQuick(&gl_combine, 0);
3997                 Cvar_SetValueQuick(&r_glsl, 0);
3998                 r_loadnormalmap = false;
3999                 r_loadgloss = false;
4000                 r_loadfog = true;
4001                 break;
4002         }
4003
4004         R_AnimCache_Free();
4005         R_FrameData_Reset();
4006
4007         r_numqueries = 0;
4008         r_maxqueries = 0;
4009         memset(r_queries, 0, sizeof(r_queries));
4010
4011         r_qwskincache = NULL;
4012         r_qwskincache_size = 0;
4013
4014         // set up r_skinframe loading system for textures
4015         memset(&r_skinframe, 0, sizeof(r_skinframe));
4016         r_skinframe.loadsequence = 1;
4017         Mem_ExpandableArray_NewArray(&r_skinframe.array, r_main_mempool, sizeof(skinframe_t), 256);
4018
4019         r_main_texturepool = R_AllocTexturePool();
4020         R_BuildBlankTextures();
4021         R_BuildNoTexture();
4022         if (vid.support.arb_texture_cube_map)
4023         {
4024                 R_BuildWhiteCube();
4025                 R_BuildNormalizationCube();
4026         }
4027         r_texture_fogattenuation = NULL;
4028         r_texture_gammaramps = NULL;
4029         //r_texture_fogintensity = NULL;
4030         memset(&r_bloomstate, 0, sizeof(r_bloomstate));
4031         memset(&r_waterstate, 0, sizeof(r_waterstate));
4032         memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
4033         Mem_ExpandableArray_NewArray(&r_glsl_permutationarray, r_main_mempool, sizeof(r_glsl_permutation_t), 256);
4034 #ifdef SUPPORTCG
4035         memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash));
4036         Mem_ExpandableArray_NewArray(&r_cg_permutationarray, r_main_mempool, sizeof(r_cg_permutation_t), 256);
4037 #endif
4038         memset(&r_svbsp, 0, sizeof (r_svbsp));
4039
4040         r_refdef.fogmasktable_density = 0;
4041 }
4042
4043 void gl_main_shutdown(void)
4044 {
4045         R_AnimCache_Free();
4046         R_FrameData_Reset();
4047
4048         R_Main_FreeViewCache();
4049
4050         if (r_maxqueries)
4051                 qglDeleteQueriesARB(r_maxqueries, r_queries);
4052
4053         r_numqueries = 0;
4054         r_maxqueries = 0;
4055         memset(r_queries, 0, sizeof(r_queries));
4056
4057         r_qwskincache = NULL;
4058         r_qwskincache_size = 0;
4059
4060         // clear out the r_skinframe state
4061         Mem_ExpandableArray_FreeArray(&r_skinframe.array);
4062         memset(&r_skinframe, 0, sizeof(r_skinframe));
4063
4064         if (r_svbsp.nodes)
4065                 Mem_Free(r_svbsp.nodes);
4066         memset(&r_svbsp, 0, sizeof (r_svbsp));
4067         R_FreeTexturePool(&r_main_texturepool);
4068         loadingscreentexture = NULL;
4069         r_texture_blanknormalmap = NULL;
4070         r_texture_white = NULL;
4071         r_texture_grey128 = NULL;
4072         r_texture_black = NULL;
4073         r_texture_whitecube = NULL;
4074         r_texture_normalizationcube = NULL;
4075         r_texture_fogattenuation = NULL;
4076         r_texture_gammaramps = NULL;
4077         //r_texture_fogintensity = NULL;
4078         memset(&r_bloomstate, 0, sizeof(r_bloomstate));
4079         memset(&r_waterstate, 0, sizeof(r_waterstate));
4080         R_GLSL_Restart_f();
4081 }
4082
4083 extern void CL_ParseEntityLump(char *entitystring);
4084 void gl_main_newmap(void)
4085 {
4086         // FIXME: move this code to client
4087         int l;
4088         char *entities, entname[MAX_QPATH];
4089         if (r_qwskincache)
4090                 Mem_Free(r_qwskincache);
4091         r_qwskincache = NULL;
4092         r_qwskincache_size = 0;
4093         if (cl.worldmodel)
4094         {
4095                 strlcpy(entname, cl.worldmodel->name, sizeof(entname));
4096                 l = (int)strlen(entname) - 4;
4097                 if (l >= 0 && !strcmp(entname + l, ".bsp"))
4098                 {
4099                         memcpy(entname + l, ".ent", 5);
4100                         if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
4101                         {
4102                                 CL_ParseEntityLump(entities);
4103                                 Mem_Free(entities);
4104                                 return;
4105                         }
4106                 }
4107                 if (cl.worldmodel->brush.entities)
4108                         CL_ParseEntityLump(cl.worldmodel->brush.entities);
4109         }
4110         R_Main_FreeViewCache();
4111
4112         R_FrameData_Reset();
4113 }
4114
4115 void GL_Main_Init(void)
4116 {
4117         r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
4118
4119         Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed");
4120         Cmd_AddCommand("r_glsl_dumpshader", R_GLSL_DumpShader_f, "dumps the engine internal default.glsl shader into glsl/default.glsl");
4121         // FIXME: the client should set up r_refdef.fog stuff including the fogmasktable
4122         if (gamemode == GAME_NEHAHRA)
4123         {
4124                 Cvar_RegisterVariable (&gl_fogenable);
4125                 Cvar_RegisterVariable (&gl_fogdensity);
4126                 Cvar_RegisterVariable (&gl_fogred);
4127                 Cvar_RegisterVariable (&gl_foggreen);
4128                 Cvar_RegisterVariable (&gl_fogblue);
4129                 Cvar_RegisterVariable (&gl_fogstart);
4130                 Cvar_RegisterVariable (&gl_fogend);
4131                 Cvar_RegisterVariable (&gl_skyclip);
4132         }
4133         Cvar_RegisterVariable(&r_motionblur);
4134         Cvar_RegisterVariable(&r_motionblur_maxblur);
4135         Cvar_RegisterVariable(&r_motionblur_bmin);
4136         Cvar_RegisterVariable(&r_motionblur_vmin);
4137         Cvar_RegisterVariable(&r_motionblur_vmax);
4138         Cvar_RegisterVariable(&r_motionblur_vcoeff);
4139         Cvar_RegisterVariable(&r_motionblur_randomize);
4140         Cvar_RegisterVariable(&r_damageblur);
4141         Cvar_RegisterVariable(&r_equalize_entities_fullbright);
4142         Cvar_RegisterVariable(&r_equalize_entities_minambient);
4143         Cvar_RegisterVariable(&r_equalize_entities_by);
4144         Cvar_RegisterVariable(&r_equalize_entities_to);
4145         Cvar_RegisterVariable(&r_depthfirst);
4146         Cvar_RegisterVariable(&r_useinfinitefarclip);
4147         Cvar_RegisterVariable(&r_farclip_base);
4148         Cvar_RegisterVariable(&r_farclip_world);
4149         Cvar_RegisterVariable(&r_nearclip);
4150         Cvar_RegisterVariable(&r_showbboxes);
4151         Cvar_RegisterVariable(&r_showsurfaces);
4152         Cvar_RegisterVariable(&r_showtris);
4153         Cvar_RegisterVariable(&r_shownormals);
4154         Cvar_RegisterVariable(&r_showlighting);
4155         Cvar_RegisterVariable(&r_showshadowvolumes);
4156         Cvar_RegisterVariable(&r_showcollisionbrushes);
4157         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
4158         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
4159         Cvar_RegisterVariable(&r_showdisabledepthtest);
4160         Cvar_RegisterVariable(&r_drawportals);
4161         Cvar_RegisterVariable(&r_drawentities);
4162         Cvar_RegisterVariable(&r_cullentities_trace);
4163         Cvar_RegisterVariable(&r_cullentities_trace_samples);
4164         Cvar_RegisterVariable(&r_cullentities_trace_tempentitysamples);
4165         Cvar_RegisterVariable(&r_cullentities_trace_enlarge);
4166         Cvar_RegisterVariable(&r_cullentities_trace_delay);
4167         Cvar_RegisterVariable(&r_drawviewmodel);
4168         Cvar_RegisterVariable(&r_speeds);
4169         Cvar_RegisterVariable(&r_fullbrights);
4170         Cvar_RegisterVariable(&r_wateralpha);
4171         Cvar_RegisterVariable(&r_dynamic);
4172         Cvar_RegisterVariable(&r_fullbright);
4173         Cvar_RegisterVariable(&r_shadows);
4174         Cvar_RegisterVariable(&r_shadows_darken);
4175         Cvar_RegisterVariable(&r_shadows_drawafterrtlighting);
4176         Cvar_RegisterVariable(&r_shadows_castfrombmodels);
4177         Cvar_RegisterVariable(&r_shadows_throwdistance);
4178         Cvar_RegisterVariable(&r_shadows_throwdirection);
4179         Cvar_RegisterVariable(&r_q1bsp_skymasking);
4180         Cvar_RegisterVariable(&r_polygonoffset_submodel_factor);
4181         Cvar_RegisterVariable(&r_polygonoffset_submodel_offset);
4182         Cvar_RegisterVariable(&r_polygonoffset_decals_factor);
4183         Cvar_RegisterVariable(&r_polygonoffset_decals_offset);
4184         Cvar_RegisterVariable(&r_fog_exp2);
4185         Cvar_RegisterVariable(&r_drawfog);
4186         Cvar_RegisterVariable(&r_transparentdepthmasking);
4187         Cvar_RegisterVariable(&r_textureunits);
4188         Cvar_RegisterVariable(&gl_combine);
4189         Cvar_RegisterVariable(&r_glsl);
4190         Cvar_RegisterVariable(&r_glsl_deluxemapping);
4191         Cvar_RegisterVariable(&r_glsl_offsetmapping);
4192         Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
4193         Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
4194         Cvar_RegisterVariable(&r_glsl_postprocess);
4195         Cvar_RegisterVariable(&r_glsl_postprocess_uservec1);
4196         Cvar_RegisterVariable(&r_glsl_postprocess_uservec2);
4197         Cvar_RegisterVariable(&r_glsl_postprocess_uservec3);
4198         Cvar_RegisterVariable(&r_glsl_postprocess_uservec4);
4199         Cvar_RegisterVariable(&r_water);
4200         Cvar_RegisterVariable(&r_water_resolutionmultiplier);
4201         Cvar_RegisterVariable(&r_water_clippingplanebias);
4202         Cvar_RegisterVariable(&r_water_refractdistort);
4203         Cvar_RegisterVariable(&r_water_reflectdistort);
4204         Cvar_RegisterVariable(&r_lerpsprites);
4205         Cvar_RegisterVariable(&r_lerpmodels);
4206         Cvar_RegisterVariable(&r_lerplightstyles);
4207         Cvar_RegisterVariable(&r_waterscroll);
4208         Cvar_RegisterVariable(&r_bloom);
4209         Cvar_RegisterVariable(&r_bloom_colorscale);
4210         Cvar_RegisterVariable(&r_bloom_brighten);
4211         Cvar_RegisterVariable(&r_bloom_blur);
4212         Cvar_RegisterVariable(&r_bloom_resolution);
4213         Cvar_RegisterVariable(&r_bloom_colorexponent);
4214         Cvar_RegisterVariable(&r_bloom_colorsubtract);
4215         Cvar_RegisterVariable(&r_hdr);
4216         Cvar_RegisterVariable(&r_hdr_scenebrightness);
4217         Cvar_RegisterVariable(&r_hdr_glowintensity);
4218         Cvar_RegisterVariable(&r_hdr_range);
4219         Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
4220         Cvar_RegisterVariable(&developer_texturelogging);
4221         Cvar_RegisterVariable(&gl_lightmaps);
4222         Cvar_RegisterVariable(&r_test);
4223         Cvar_RegisterVariable(&r_batchmode);
4224         Cvar_RegisterVariable(&r_glsl_saturation);
4225         Cvar_RegisterVariable(&r_framedatasize);
4226         if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
4227                 Cvar_SetValue("r_fullbrights", 0);
4228         R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap);
4229
4230         Cvar_RegisterVariable(&r_track_sprites);
4231         Cvar_RegisterVariable(&r_track_sprites_flags);
4232         Cvar_RegisterVariable(&r_track_sprites_scalew);
4233         Cvar_RegisterVariable(&r_track_sprites_scaleh);
4234 }
4235
4236 extern void R_Textures_Init(void);
4237 extern void GL_Draw_Init(void);
4238 extern void GL_Main_Init(void);
4239 extern void R_Shadow_Init(void);
4240 extern void R_Sky_Init(void);
4241 extern void GL_Surf_Init(void);
4242 extern void R_Particles_Init(void);
4243 extern void R_Explosion_Init(void);
4244 extern void gl_backend_init(void);
4245 extern void Sbar_Init(void);
4246 extern void R_LightningBeams_Init(void);
4247 extern void Mod_RenderInit(void);
4248 extern void Font_Init(void);
4249
4250 void Render_Init(void)
4251 {
4252         gl_backend_init();
4253         R_Textures_Init();
4254         GL_Main_Init();
4255         Font_Init();
4256         GL_Draw_Init();
4257         R_Shadow_Init();
4258         R_Sky_Init();
4259         GL_Surf_Init();
4260         Sbar_Init();
4261         R_Particles_Init();
4262         R_Explosion_Init();
4263         R_LightningBeams_Init();
4264         Mod_RenderInit();
4265 }
4266
4267 /*
4268 ===============
4269 GL_Init
4270 ===============
4271 */
4272 extern char *ENGINE_EXTENSIONS;
4273 void GL_Init (void)
4274 {
4275         gl_renderer = (const char *)qglGetString(GL_RENDERER);
4276         gl_vendor = (const char *)qglGetString(GL_VENDOR);
4277         gl_version = (const char *)qglGetString(GL_VERSION);
4278         gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
4279
4280         if (!gl_extensions)
4281                 gl_extensions = "";
4282         if (!gl_platformextensions)
4283                 gl_platformextensions = "";
4284
4285         Con_Printf("GL_VENDOR: %s\n", gl_vendor);
4286         Con_Printf("GL_RENDERER: %s\n", gl_renderer);
4287         Con_Printf("GL_VERSION: %s\n", gl_version);
4288         Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
4289         Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
4290
4291         VID_CheckExtensions();
4292
4293         // LordHavoc: report supported extensions
4294         Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
4295
4296         // clear to black (loading plaque will be seen over this)
4297         CHECKGLERROR
4298         qglClearColor(0,0,0,1);CHECKGLERROR
4299         qglClear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
4300 }
4301
4302 int R_CullBox(const vec3_t mins, const vec3_t maxs)
4303 {
4304         int i;
4305         mplane_t *p;
4306         for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
4307         {
4308                 // skip nearclip plane, it often culls portals when you are very close, and is almost never useful
4309                 if (i == 4)
4310                         continue;
4311                 p = r_refdef.view.frustum + i;
4312                 switch(p->signbits)
4313                 {
4314                 default:
4315                 case 0:
4316                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
4317                                 return true;
4318                         break;
4319                 case 1:
4320                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
4321                                 return true;
4322                         break;
4323                 case 2:
4324                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
4325                                 return true;
4326                         break;
4327                 case 3:
4328                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
4329                                 return true;
4330                         break;
4331                 case 4:
4332                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
4333                                 return true;
4334                         break;
4335                 case 5:
4336                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
4337                                 return true;
4338                         break;
4339                 case 6:
4340                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
4341                                 return true;
4342                         break;
4343                 case 7:
4344                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
4345                                 return true;
4346                         break;
4347                 }
4348         }
4349         return false;
4350 }
4351
4352 int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes)
4353 {
4354         int i;
4355         const mplane_t *p;
4356         for (i = 0;i < numplanes;i++)
4357         {
4358                 p = planes + i;
4359                 switch(p->signbits)
4360                 {
4361                 default:
4362                 case 0:
4363                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
4364                                 return true;
4365                         break;
4366                 case 1:
4367                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
4368                                 return true;
4369                         break;
4370                 case 2:
4371                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
4372                                 return true;
4373                         break;
4374                 case 3:
4375                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
4376                                 return true;
4377                         break;
4378                 case 4:
4379                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
4380                                 return true;
4381                         break;
4382                 case 5:
4383                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
4384                                 return true;
4385                         break;
4386                 case 6:
4387                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
4388                                 return true;
4389                         break;
4390                 case 7:
4391                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
4392                                 return true;
4393                         break;
4394                 }
4395         }
4396         return false;
4397 }
4398
4399 //==================================================================================
4400
4401 // LordHavoc: this stores temporary data used within the same frame
4402
4403 qboolean r_framedata_failed;
4404 static size_t r_framedata_size;
4405 static size_t r_framedata_current;
4406 static void *r_framedata_base;
4407
4408 void R_FrameData_Reset(void)
4409 {
4410         if (r_framedata_base);
4411                 Mem_Free(r_framedata_base);
4412         r_framedata_base = NULL;
4413         r_framedata_size = 0;
4414         r_framedata_current = 0;
4415         r_framedata_failed = false;
4416 }
4417
4418 void R_FrameData_NewFrame(void)
4419 {
4420         size_t wantedsize;
4421         if (r_framedata_failed)
4422                 Cvar_SetValueQuick(&r_framedatasize, r_framedatasize.value + 1.0f);
4423         wantedsize = (size_t)(r_framedatasize.value * 1024*1024);
4424         wantedsize = bound(65536, wantedsize, 128*1024*1024);
4425         if (r_framedata_size != wantedsize)
4426         {
4427                 r_framedata_size = wantedsize;
4428                 if (r_framedata_base);
4429                         Mem_Free(r_framedata_base);
4430                 r_framedata_base = Mem_Alloc(r_main_mempool, r_framedata_size);
4431         }
4432         r_framedata_current = 0;
4433         r_framedata_failed = false;
4434 }
4435
4436 void *R_FrameData_Alloc(size_t size)
4437 {
4438         void *data;
4439
4440         // align to 16 byte boundary
4441         size = (size + 15) & ~15;
4442         data = (void *)((unsigned char*)r_framedata_base + r_framedata_current);
4443         r_framedata_current += size;
4444
4445         // check overflow
4446         if (r_framedata_current > r_framedata_size)
4447                 r_framedata_failed = true;
4448
4449         // return NULL on everything after a failure
4450         if (r_framedata_failed)
4451                 return NULL;
4452
4453         return data;
4454 }
4455
4456 void *R_FrameData_Store(size_t size, void *data)
4457 {
4458         void *d = R_FrameData_Alloc(size);
4459         if (d)
4460                 memcpy(d, data, size);
4461         return d;
4462 }
4463
4464 //==================================================================================
4465
4466 // LordHavoc: animcache originally written by Echon, rewritten since then
4467
4468 /**
4469  * Animation cache prevents re-generating mesh data for an animated model
4470  * multiple times in one frame for lighting, shadowing, reflections, etc.
4471  */
4472
4473 void R_AnimCache_Free(void)
4474 {
4475 }
4476
4477 void R_AnimCache_ClearCache(void)
4478 {
4479         int i;
4480         entity_render_t *ent;
4481
4482         for (i = 0;i < r_refdef.scene.numentities;i++)
4483         {
4484                 ent = r_refdef.scene.entities[i];
4485                 ent->animcache_vertex3f = NULL;
4486                 ent->animcache_normal3f = NULL;
4487                 ent->animcache_svector3f = NULL;
4488                 ent->animcache_tvector3f = NULL;
4489         }
4490 }
4491
4492 qboolean R_AnimCache_GetEntity(entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
4493 {
4494         dp_model_t *model = ent->model;
4495         int numvertices;
4496         // see if it's already cached this frame
4497         if (ent->animcache_vertex3f)
4498         {
4499                 // add normals/tangents if needed
4500                 if (wantnormals || wanttangents)
4501                 {
4502                         if (ent->animcache_normal3f)
4503                                 wantnormals = false;
4504                         if (ent->animcache_svector3f)
4505                                 wanttangents = false;
4506                         if (wantnormals || wanttangents)
4507                         {
4508                                 numvertices = model->surfmesh.num_vertices;
4509                                 if (wantnormals)
4510                                         ent->animcache_normal3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
4511                                 if (wanttangents)
4512                                 {
4513                                         ent->animcache_svector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
4514                                         ent->animcache_tvector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
4515                                 }
4516                                 if (!r_framedata_failed)
4517                                         model->AnimateVertices(model, ent->frameblend, ent->skeleton, NULL, wantnormals ? ent->animcache_normal3f : NULL, wanttangents ? ent->animcache_svector3f : NULL, wanttangents ? ent->animcache_tvector3f : NULL);
4518                         }
4519                 }
4520         }
4521         else
4522         {
4523                 // see if this ent is worth caching
4524                 if (!model || !model->Draw || !model->surfmesh.isanimated || !model->AnimateVertices || (ent->frameblend[0].lerp == 1 && ent->frameblend[0].subframe == 0 && !ent->skeleton))
4525                         return false;
4526                 // get some memory for this entity and generate mesh data
4527                 numvertices = model->surfmesh.num_vertices;
4528                 ent->animcache_vertex3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
4529                 if (wantnormals)
4530                         ent->animcache_normal3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
4531                 if (wanttangents)
4532                 {
4533                         ent->animcache_svector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
4534                         ent->animcache_tvector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
4535                 }
4536                 if (!r_framedata_failed)
4537                         model->AnimateVertices(model, ent->frameblend, ent->skeleton, ent->animcache_vertex3f, ent->animcache_normal3f, ent->animcache_svector3f, ent->animcache_tvector3f);
4538         }
4539         return !r_framedata_failed;
4540 }
4541
4542 void R_AnimCache_CacheVisibleEntities(void)
4543 {
4544         int i;
4545         qboolean wantnormals = !r_showsurfaces.integer;
4546         qboolean wanttangents = !r_showsurfaces.integer;
4547
4548         switch(vid.renderpath)
4549         {
4550         case RENDERPATH_GL20:
4551         case RENDERPATH_CGGL:
4552                 break;
4553         case RENDERPATH_GL13:
4554         case RENDERPATH_GL11:
4555                 wanttangents = false;
4556                 break;
4557         }
4558
4559         // TODO: thread this
4560         // NOTE: R_PrepareRTLights() also caches entities
4561
4562         for (i = 0;i < r_refdef.scene.numentities;i++)
4563                 if (r_refdef.viewcache.entityvisible[i])
4564                         R_AnimCache_GetEntity(r_refdef.scene.entities[i], wantnormals, wanttangents);
4565
4566         if (r_shadows.integer)
4567                 for (i = 0;i < r_refdef.scene.numentities;i++)
4568                         if (!r_refdef.viewcache.entityvisible[i])
4569                                 R_AnimCache_GetEntity(r_refdef.scene.entities[i], false, false);
4570 }
4571
4572 //==================================================================================
4573
4574 static void R_View_UpdateEntityLighting (void)
4575 {
4576         int i;
4577         entity_render_t *ent;
4578         vec3_t tempdiffusenormal, avg;
4579         vec_t f, fa, fd, fdd;
4580
4581         for (i = 0;i < r_refdef.scene.numentities;i++)
4582         {
4583                 ent = r_refdef.scene.entities[i];
4584
4585                 // skip unseen models
4586                 if (!r_refdef.viewcache.entityvisible[i] && r_shadows.integer != 1)
4587                         continue;
4588
4589                 // skip bsp models
4590                 if (ent->model && ent->model->brush.num_leafs)
4591                 {
4592                         // TODO: use modellight for r_ambient settings on world?
4593                         VectorSet(ent->modellight_ambient, 0, 0, 0);
4594                         VectorSet(ent->modellight_diffuse, 0, 0, 0);
4595                         VectorSet(ent->modellight_lightdir, 0, 0, 1);
4596                         continue;
4597                 }
4598
4599                 // fetch the lighting from the worldmodel data
4600                 VectorClear(ent->modellight_ambient);
4601                 VectorClear(ent->modellight_diffuse);
4602                 VectorClear(tempdiffusenormal);
4603                 if ((ent->flags & RENDER_LIGHT) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint)
4604                 {
4605                         vec3_t org;
4606                         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
4607                         r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, org, ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal);
4608                         if(ent->flags & RENDER_EQUALIZE)
4609                         {
4610                                 // first fix up ambient lighting...
4611                                 if(r_equalize_entities_minambient.value > 0)
4612                                 {
4613                                         fd = 0.299f * ent->modellight_diffuse[0] + 0.587f * ent->modellight_diffuse[1] + 0.114f * ent->modellight_diffuse[2];
4614                                         if(fd > 0)
4615                                         {
4616                                                 fa = (0.299f * ent->modellight_ambient[0] + 0.587f * ent->modellight_ambient[1] + 0.114f * ent->modellight_ambient[2]);
4617                                                 if(fa < r_equalize_entities_minambient.value * fd)
4618                                                 {
4619                                                         // solve:
4620                                                         //   fa'/fd' = minambient
4621                                                         //   fa'+0.25*fd' = fa+0.25*fd
4622                                                         //   ...
4623                                                         //   fa' = fd' * minambient
4624                                                         //   fd'*(0.25+minambient) = fa+0.25*fd
4625                                                         //   ...
4626                                                         //   fd' = (fa+0.25*fd) * 1 / (0.25+minambient)
4627                                                         //   fa' = (fa+0.25*fd) * minambient / (0.25+minambient)
4628                                                         //   ...
4629                                                         fdd = (fa + 0.25f * fd) / (0.25f + r_equalize_entities_minambient.value);
4630                                                         f = fdd / fd; // f>0 because all this is additive; f<1 because fdd<fd because this follows from fa < r_equalize_entities_minambient.value * fd
4631                                                         VectorMA(ent->modellight_ambient, (1-f)*0.25f, ent->modellight_diffuse, ent->modellight_ambient);
4632                                                         VectorScale(ent->modellight_diffuse, f, ent->modellight_diffuse);
4633                                                 }
4634                                         }
4635                                 }
4636
4637                                 if(r_equalize_entities_to.value > 0 && r_equalize_entities_by.value != 0)
4638                                 {
4639                                         VectorMA(ent->modellight_ambient, 0.25f, ent->modellight_diffuse, avg);
4640                                         f = 0.299f * avg[0] + 0.587f * avg[1] + 0.114f * avg[2];
4641                                         if(f > 0)
4642                                         {
4643                                                 f = pow(f / r_equalize_entities_to.value, -r_equalize_entities_by.value);
4644                                                 VectorScale(ent->modellight_ambient, f, ent->modellight_ambient);
4645                                                 VectorScale(ent->modellight_diffuse, f, ent->modellight_diffuse);
4646                                         }
4647                                 }
4648                         }
4649                 }
4650                 else // highly rare
4651                         VectorSet(ent->modellight_ambient, 1, 1, 1);
4652
4653                 // move the light direction into modelspace coordinates for lighting code
4654                 Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, ent->modellight_lightdir);
4655                 if(VectorLength2(ent->modellight_lightdir) == 0)
4656                         VectorSet(ent->modellight_lightdir, 0, 0, 1); // have to set SOME valid vector here
4657                 VectorNormalize(ent->modellight_lightdir);
4658         }
4659 }
4660
4661 #define MAX_LINEOFSIGHTTRACES 64
4662
4663 static qboolean R_CanSeeBox(int numsamples, vec_t enlarge, vec3_t eye, vec3_t entboxmins, vec3_t entboxmaxs)
4664 {
4665         int i;
4666         vec3_t boxmins, boxmaxs;
4667         vec3_t start;
4668         vec3_t end;
4669         dp_model_t *model = r_refdef.scene.worldmodel;
4670
4671         if (!model || !model->brush.TraceLineOfSight)
4672                 return true;
4673
4674         // expand the box a little
4675         boxmins[0] = (enlarge+1) * entboxmins[0] - enlarge * entboxmaxs[0];
4676         boxmaxs[0] = (enlarge+1) * entboxmaxs[0] - enlarge * entboxmins[0];
4677         boxmins[1] = (enlarge+1) * entboxmins[1] - enlarge * entboxmaxs[1];
4678         boxmaxs[1] = (enlarge+1) * entboxmaxs[1] - enlarge * entboxmins[1];
4679         boxmins[2] = (enlarge+1) * entboxmins[2] - enlarge * entboxmaxs[2];
4680         boxmaxs[2] = (enlarge+1) * entboxmaxs[2] - enlarge * entboxmins[2];
4681
4682         // try center
4683         VectorCopy(eye, start);
4684         VectorMAM(0.5f, boxmins, 0.5f, boxmaxs, end);
4685         if (model->brush.TraceLineOfSight(model, start, end))
4686                 return true;
4687
4688         // try various random positions
4689         for (i = 0;i < numsamples;i++)
4690         {
4691                 VectorSet(end, lhrandom(boxmins[0], boxmaxs[0]), lhrandom(boxmins[1], boxmaxs[1]), lhrandom(boxmins[2], boxmaxs[2]));
4692                 if (model->brush.TraceLineOfSight(model, start, end))
4693                         return true;
4694         }
4695
4696         return false;
4697 }
4698
4699
4700 static void R_View_UpdateEntityVisible (void)
4701 {
4702         int i;
4703         int renderimask;
4704         int samples;
4705         entity_render_t *ent;
4706
4707         renderimask = r_refdef.envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL) : ((chase_active.integer || r_waterstate.renderingscene) ? RENDER_VIEWMODEL : RENDER_EXTERIORMODEL);
4708         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs)
4709         {
4710                 // worldmodel can check visibility
4711                 memset(r_refdef.viewcache.entityvisible, 0, r_refdef.scene.numentities);
4712                 for (i = 0;i < r_refdef.scene.numentities;i++)
4713                 {
4714                         ent = r_refdef.scene.entities[i];
4715                         if (!(ent->flags & renderimask))
4716                         if (!R_CullBox(ent->mins, ent->maxs) || (ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE)))
4717                         if ((ent->flags & (RENDER_NODEPTHTEST | RENDER_VIEWMODEL)) || r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.scene.worldmodel, r_refdef.viewcache.world_leafvisible, ent->mins, ent->maxs))
4718                                 r_refdef.viewcache.entityvisible[i] = true;
4719                 }
4720                 if(r_cullentities_trace.integer && r_refdef.scene.worldmodel->brush.TraceLineOfSight)
4721                 {
4722                         for (i = 0;i < r_refdef.scene.numentities;i++)
4723                         {
4724                                 ent = r_refdef.scene.entities[i];
4725                                 if(r_refdef.viewcache.entityvisible[i] && !(ent->flags & (RENDER_VIEWMODEL | RENDER_NOCULL | RENDER_NODEPTHTEST)) && !(ent->model && (ent->model->name[0] == '*')))
4726                                 {
4727                                         samples = ent->entitynumber ? r_cullentities_trace_samples.integer : r_cullentities_trace_tempentitysamples.integer;
4728                                         if (samples < 0)
4729                                                 continue; // temp entities do pvs only
4730                                         if(R_CanSeeBox(samples, r_cullentities_trace_enlarge.value, r_refdef.view.origin, ent->mins, ent->maxs))
4731                                                 ent->last_trace_visibility = realtime;
4732                                         if(ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value)
4733                                                 r_refdef.viewcache.entityvisible[i] = 0;
4734                                 }
4735                         }
4736                 }
4737         }
4738         else
4739         {
4740                 // no worldmodel or it can't check visibility
4741                 for (i = 0;i < r_refdef.scene.numentities;i++)
4742                 {
4743                         ent = r_refdef.scene.entities[i];
4744                         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));
4745                 }
4746         }
4747 }
4748
4749 /// only used if skyrendermasked, and normally returns false
4750 int R_DrawBrushModelsSky (void)
4751 {
4752         int i, sky;
4753         entity_render_t *ent;
4754
4755         sky = false;
4756         for (i = 0;i < r_refdef.scene.numentities;i++)
4757         {
4758                 if (!r_refdef.viewcache.entityvisible[i])
4759                         continue;
4760                 ent = r_refdef.scene.entities[i];
4761                 if (!ent->model || !ent->model->DrawSky)
4762                         continue;
4763                 ent->model->DrawSky(ent);
4764                 sky = true;
4765         }
4766         return sky;
4767 }
4768
4769 static void R_DrawNoModel(entity_render_t *ent);
4770 static void R_DrawModels(void)
4771 {
4772         int i;
4773         entity_render_t *ent;
4774
4775         for (i = 0;i < r_refdef.scene.numentities;i++)
4776         {
4777                 if (!r_refdef.viewcache.entityvisible[i])
4778                         continue;
4779                 ent = r_refdef.scene.entities[i];
4780                 r_refdef.stats.entities++;
4781                 if (ent->model && ent->model->Draw != NULL)
4782                         ent->model->Draw(ent);
4783                 else
4784                         R_DrawNoModel(ent);
4785         }
4786 }
4787
4788 static void R_DrawModelsDepth(void)
4789 {
4790         int i;
4791         entity_render_t *ent;
4792
4793         for (i = 0;i < r_refdef.scene.numentities;i++)
4794         {
4795                 if (!r_refdef.viewcache.entityvisible[i])
4796                         continue;
4797                 ent = r_refdef.scene.entities[i];
4798                 if (ent->model && ent->model->DrawDepth != NULL)
4799                         ent->model->DrawDepth(ent);
4800         }
4801 }
4802
4803 static void R_DrawModelsDebug(void)
4804 {
4805         int i;
4806         entity_render_t *ent;
4807
4808         for (i = 0;i < r_refdef.scene.numentities;i++)
4809         {
4810                 if (!r_refdef.viewcache.entityvisible[i])
4811                         continue;
4812                 ent = r_refdef.scene.entities[i];
4813                 if (ent->model && ent->model->DrawDebug != NULL)
4814                         ent->model->DrawDebug(ent);
4815         }
4816 }
4817
4818 static void R_DrawModelsAddWaterPlanes(void)
4819 {
4820         int i;
4821         entity_render_t *ent;
4822
4823         for (i = 0;i < r_refdef.scene.numentities;i++)
4824         {
4825                 if (!r_refdef.viewcache.entityvisible[i])
4826                         continue;
4827                 ent = r_refdef.scene.entities[i];
4828                 if (ent->model && ent->model->DrawAddWaterPlanes != NULL)
4829                         ent->model->DrawAddWaterPlanes(ent);
4830         }
4831 }
4832
4833 static void R_View_SetFrustum(void)
4834 {
4835         int i;
4836         double slopex, slopey;
4837         vec3_t forward, left, up, origin;
4838
4839         // we can't trust r_refdef.view.forward and friends in reflected scenes
4840         Matrix4x4_ToVectors(&r_refdef.view.matrix, forward, left, up, origin);
4841
4842 #if 0
4843         r_refdef.view.frustum[0].normal[0] = 0 - 1.0 / r_refdef.view.frustum_x;
4844         r_refdef.view.frustum[0].normal[1] = 0 - 0;
4845         r_refdef.view.frustum[0].normal[2] = -1 - 0;
4846         r_refdef.view.frustum[1].normal[0] = 0 + 1.0 / r_refdef.view.frustum_x;
4847         r_refdef.view.frustum[1].normal[1] = 0 + 0;
4848         r_refdef.view.frustum[1].normal[2] = -1 + 0;
4849         r_refdef.view.frustum[2].normal[0] = 0 - 0;
4850         r_refdef.view.frustum[2].normal[1] = 0 - 1.0 / r_refdef.view.frustum_y;
4851         r_refdef.view.frustum[2].normal[2] = -1 - 0;
4852         r_refdef.view.frustum[3].normal[0] = 0 + 0;
4853         r_refdef.view.frustum[3].normal[1] = 0 + 1.0 / r_refdef.view.frustum_y;
4854         r_refdef.view.frustum[3].normal[2] = -1 + 0;
4855 #endif
4856
4857 #if 0
4858         zNear = r_refdef.nearclip;
4859         nudge = 1.0 - 1.0 / (1<<23);
4860         r_refdef.view.frustum[4].normal[0] = 0 - 0;
4861         r_refdef.view.frustum[4].normal[1] = 0 - 0;
4862         r_refdef.view.frustum[4].normal[2] = -1 - -nudge;
4863         r_refdef.view.frustum[4].dist = 0 - -2 * zNear * nudge;
4864         r_refdef.view.frustum[5].normal[0] = 0 + 0;
4865         r_refdef.view.frustum[5].normal[1] = 0 + 0;
4866         r_refdef.view.frustum[5].normal[2] = -1 + -nudge;
4867         r_refdef.view.frustum[5].dist = 0 + -2 * zNear * nudge;
4868 #endif
4869
4870
4871
4872 #if 0
4873         r_refdef.view.frustum[0].normal[0] = m[3] - m[0];
4874         r_refdef.view.frustum[0].normal[1] = m[7] - m[4];
4875         r_refdef.view.frustum[0].normal[2] = m[11] - m[8];
4876         r_refdef.view.frustum[0].dist = m[15] - m[12];
4877
4878         r_refdef.view.frustum[1].normal[0] = m[3] + m[0];
4879         r_refdef.view.frustum[1].normal[1] = m[7] + m[4];
4880         r_refdef.view.frustum[1].normal[2] = m[11] + m[8];
4881         r_refdef.view.frustum[1].dist = m[15] + m[12];
4882
4883         r_refdef.view.frustum[2].normal[0] = m[3] - m[1];
4884         r_refdef.view.frustum[2].normal[1] = m[7] - m[5];
4885         r_refdef.view.frustum[2].normal[2] = m[11] - m[9];
4886         r_refdef.view.frustum[2].dist = m[15] - m[13];
4887
4888         r_refdef.view.frustum[3].normal[0] = m[3] + m[1];
4889         r_refdef.view.frustum[3].normal[1] = m[7] + m[5];
4890         r_refdef.view.frustum[3].normal[2] = m[11] + m[9];
4891         r_refdef.view.frustum[3].dist = m[15] + m[13];
4892
4893         r_refdef.view.frustum[4].normal[0] = m[3] - m[2];
4894         r_refdef.view.frustum[4].normal[1] = m[7] - m[6];
4895         r_refdef.view.frustum[4].normal[2] = m[11] - m[10];
4896         r_refdef.view.frustum[4].dist = m[15] - m[14];
4897
4898         r_refdef.view.frustum[5].normal[0] = m[3] + m[2];
4899         r_refdef.view.frustum[5].normal[1] = m[7] + m[6];
4900         r_refdef.view.frustum[5].normal[2] = m[11] + m[10];
4901         r_refdef.view.frustum[5].dist = m[15] + m[14];
4902 #endif
4903
4904         if (r_refdef.view.useperspective)
4905         {
4906                 slopex = 1.0 / r_refdef.view.frustum_x;
4907                 slopey = 1.0 / r_refdef.view.frustum_y;
4908                 VectorMA(forward, -slopex, left, r_refdef.view.frustum[0].normal);
4909                 VectorMA(forward,  slopex, left, r_refdef.view.frustum[1].normal);
4910                 VectorMA(forward, -slopey, up  , r_refdef.view.frustum[2].normal);
4911                 VectorMA(forward,  slopey, up  , r_refdef.view.frustum[3].normal);
4912                 VectorCopy(forward, r_refdef.view.frustum[4].normal);
4913
4914                 // Leaving those out was a mistake, those were in the old code, and they
4915                 // fix a reproducable bug in this one: frustum culling got fucked up when viewmatrix was an identity matrix
4916                 // I couldn't reproduce it after adding those normalizations. --blub
4917                 VectorNormalize(r_refdef.view.frustum[0].normal);
4918                 VectorNormalize(r_refdef.view.frustum[1].normal);
4919                 VectorNormalize(r_refdef.view.frustum[2].normal);
4920                 VectorNormalize(r_refdef.view.frustum[3].normal);
4921
4922                 // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
4923                 VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward, -1024 * r_refdef.view.frustum_x, left, -1024 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[0]);
4924                 VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward,  1024 * r_refdef.view.frustum_x, left, -1024 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[1]);
4925                 VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward, -1024 * r_refdef.view.frustum_x, left,  1024 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[2]);
4926                 VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward,  1024 * r_refdef.view.frustum_x, left,  1024 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[3]);
4927
4928                 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal);
4929                 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal);
4930                 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal);
4931                 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal);
4932                 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
4933         }
4934         else
4935         {
4936                 VectorScale(left, -r_refdef.view.ortho_x, r_refdef.view.frustum[0].normal);
4937                 VectorScale(left,  r_refdef.view.ortho_x, r_refdef.view.frustum[1].normal);
4938                 VectorScale(up, -r_refdef.view.ortho_y, r_refdef.view.frustum[2].normal);
4939                 VectorScale(up,  r_refdef.view.ortho_y, r_refdef.view.frustum[3].normal);
4940                 VectorCopy(forward, r_refdef.view.frustum[4].normal);
4941                 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal) + r_refdef.view.ortho_x;
4942                 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal) + r_refdef.view.ortho_x;
4943                 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal) + r_refdef.view.ortho_y;
4944                 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal) + r_refdef.view.ortho_y;
4945                 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
4946         }
4947         r_refdef.view.numfrustumplanes = 5;
4948
4949         if (r_refdef.view.useclipplane)
4950         {
4951                 r_refdef.view.numfrustumplanes = 6;
4952                 r_refdef.view.frustum[5] = r_refdef.view.clipplane;
4953         }
4954
4955         for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
4956                 PlaneClassify(r_refdef.view.frustum + i);
4957
4958         // LordHavoc: note to all quake engine coders, Quake had a special case
4959         // for 90 degrees which assumed a square view (wrong), so I removed it,
4960         // Quake2 has it disabled as well.
4961
4962         // rotate R_VIEWFORWARD right by FOV_X/2 degrees
4963         //RotatePointAroundVector( r_refdef.view.frustum[0].normal, up, forward, -(90 - r_refdef.fov_x / 2));
4964         //r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, frustum[0].normal);
4965         //PlaneClassify(&frustum[0]);
4966
4967         // rotate R_VIEWFORWARD left by FOV_X/2 degrees
4968         //RotatePointAroundVector( r_refdef.view.frustum[1].normal, up, forward, (90 - r_refdef.fov_x / 2));
4969         //r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, frustum[1].normal);
4970         //PlaneClassify(&frustum[1]);
4971
4972         // rotate R_VIEWFORWARD up by FOV_X/2 degrees
4973         //RotatePointAroundVector( r_refdef.view.frustum[2].normal, left, forward, -(90 - r_refdef.fov_y / 2));
4974         //r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, frustum[2].normal);
4975         //PlaneClassify(&frustum[2]);
4976
4977         // rotate R_VIEWFORWARD down by FOV_X/2 degrees
4978         //RotatePointAroundVector( r_refdef.view.frustum[3].normal, left, forward, (90 - r_refdef.fov_y / 2));
4979         //r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, frustum[3].normal);
4980         //PlaneClassify(&frustum[3]);
4981
4982         // nearclip plane
4983         //VectorCopy(forward, r_refdef.view.frustum[4].normal);
4984         //r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, frustum[4].normal) + r_nearclip.value;
4985         //PlaneClassify(&frustum[4]);
4986 }
4987
4988 void R_View_Update(void)
4989 {
4990         R_Main_ResizeViewCache();
4991         R_View_SetFrustum();
4992         R_View_WorldVisibility(r_refdef.view.useclipplane);
4993         R_View_UpdateEntityVisible();
4994         R_View_UpdateEntityLighting();
4995 }
4996
4997 void R_SetupView(qboolean allowwaterclippingplane)
4998 {
4999         const float *customclipplane = NULL;
5000         float plane[4];
5001         if (r_refdef.view.useclipplane && allowwaterclippingplane)
5002         {
5003                 // LordHavoc: couldn't figure out how to make this approach the
5004                 vec_t dist = r_refdef.view.clipplane.dist - r_water_clippingplanebias.value;
5005                 vec_t viewdist = DotProduct(r_refdef.view.origin, r_refdef.view.clipplane.normal);
5006                 if (viewdist < r_refdef.view.clipplane.dist + r_water_clippingplanebias.value)
5007                         dist = r_refdef.view.clipplane.dist;
5008                 plane[0] = r_refdef.view.clipplane.normal[0];
5009                 plane[1] = r_refdef.view.clipplane.normal[1];
5010                 plane[2] = r_refdef.view.clipplane.normal[2];
5011                 plane[3] = dist;
5012                 customclipplane = plane;
5013         }
5014
5015         if (!r_refdef.view.useperspective)
5016                 R_Viewport_InitOrtho(&r_refdef.view.viewport, &r_refdef.view.matrix, r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height, -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, customclipplane);
5017         else if (vid.stencil && r_useinfinitefarclip.integer)
5018                 R_Viewport_InitPerspectiveInfinite(&r_refdef.view.viewport, &r_refdef.view.matrix, r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height, r_refdef.view.frustum_x, r_refdef.view.frustum_y, r_refdef.nearclip, customclipplane);
5019         else
5020                 R_Viewport_InitPerspective(&r_refdef.view.viewport, &r_refdef.view.matrix, r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height, r_refdef.view.frustum_x, r_refdef.view.frustum_y, r_refdef.nearclip, r_refdef.farclip, customclipplane);
5021         R_SetViewport(&r_refdef.view.viewport);
5022 }
5023
5024 void R_EntityMatrix(const matrix4x4_t *matrix)
5025 {
5026         if (gl_modelmatrixchanged || memcmp(matrix, &gl_modelmatrix, sizeof(matrix4x4_t)))
5027         {
5028                 gl_modelmatrixchanged = false;
5029                 gl_modelmatrix = *matrix;
5030                 Matrix4x4_Concat(&gl_modelviewmatrix, &gl_viewmatrix, &gl_modelmatrix);
5031                 Matrix4x4_Concat(&gl_modelviewprojectionmatrix, &gl_projectionmatrix, &gl_modelviewmatrix);
5032                 Matrix4x4_ToArrayFloatGL(&gl_modelviewmatrix, gl_modelview16f);
5033                 Matrix4x4_ToArrayFloatGL(&gl_modelviewprojectionmatrix, gl_modelviewprojection16f);
5034                 CHECKGLERROR
5035                 switch(vid.renderpath)
5036                 {
5037                 case RENDERPATH_GL20:
5038                         if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f);
5039                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
5040                         break;
5041                 case RENDERPATH_CGGL:
5042 #ifdef SUPPORTCG
5043                         CHECKCGERROR
5044                         if (r_cg_permutation && r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR
5045                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
5046 #endif
5047                         break;
5048                 case RENDERPATH_GL13:
5049                 case RENDERPATH_GL11:
5050                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
5051                         break;
5052                 }
5053         }
5054 }
5055
5056 void R_ResetViewRendering2D(void)
5057 {
5058         r_viewport_t viewport;
5059         DrawQ_Finish();
5060
5061         // GL is weird because it's bottom to top, r_refdef.view.y is top to bottom
5062         R_Viewport_InitOrtho(&viewport, &identitymatrix, r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height, 0, 0, 1, 1, -10, 100, NULL);
5063         R_SetViewport(&viewport);
5064         GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
5065         GL_Color(1, 1, 1, 1);
5066         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5067         GL_BlendFunc(GL_ONE, GL_ZERO);
5068         GL_AlphaTest(false);
5069         GL_ScissorTest(false);
5070         GL_DepthMask(false);
5071         GL_DepthRange(0, 1);
5072         GL_DepthTest(false);
5073         R_EntityMatrix(&identitymatrix);
5074         R_Mesh_ResetTextureState();
5075         GL_PolygonOffset(0, 0);
5076         qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
5077         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
5078         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
5079         qglStencilMask(~0);CHECKGLERROR
5080         qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
5081         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
5082         GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces
5083 }
5084
5085 void R_ResetViewRendering3D(void)
5086 {
5087         DrawQ_Finish();
5088
5089         R_SetupView(true);
5090         GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5091         GL_Color(1, 1, 1, 1);
5092         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5093         GL_BlendFunc(GL_ONE, GL_ZERO);
5094         GL_AlphaTest(false);
5095         GL_ScissorTest(true);
5096         GL_DepthMask(true);
5097         GL_DepthRange(0, 1);
5098         GL_DepthTest(true);
5099         R_EntityMatrix(&identitymatrix);
5100         R_Mesh_ResetTextureState();
5101         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
5102         qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
5103         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
5104         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
5105         qglStencilMask(~0);CHECKGLERROR
5106         qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
5107         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
5108         GL_CullFace(r_refdef.view.cullface_back);
5109 }
5110
5111 void R_RenderScene(void);
5112 void R_RenderWaterPlanes(void);
5113
5114 static void R_Water_StartFrame(void)
5115 {
5116         int i;
5117         int waterwidth, waterheight, texturewidth, textureheight;
5118         r_waterstate_waterplane_t *p;
5119
5120         if (vid.width > (int)vid.maxtexturesize_2d || vid.height > (int)vid.maxtexturesize_2d)
5121                 return;
5122
5123         switch(vid.renderpath)
5124         {
5125         case RENDERPATH_GL20:
5126         case RENDERPATH_CGGL:
5127                 break;
5128         case RENDERPATH_GL13:
5129         case RENDERPATH_GL11:
5130                 return;
5131         }
5132
5133         // set waterwidth and waterheight to the water resolution that will be
5134         // used (often less than the screen resolution for faster rendering)
5135         waterwidth = (int)bound(1, vid.width * r_water_resolutionmultiplier.value, vid.width);
5136         waterheight = (int)bound(1, vid.height * r_water_resolutionmultiplier.value, vid.height);
5137
5138         // calculate desired texture sizes
5139         // can't use water if the card does not support the texture size
5140         if (!r_water.integer || r_showsurfaces.integer)
5141                 texturewidth = textureheight = waterwidth = waterheight = 0;
5142         else if (vid.support.arb_texture_non_power_of_two)
5143         {
5144                 texturewidth = waterwidth;
5145                 textureheight = waterheight;
5146         }
5147         else
5148         {
5149                 for (texturewidth   = 1;texturewidth   < waterwidth ;texturewidth   *= 2);
5150                 for (textureheight  = 1;textureheight  < waterheight;textureheight  *= 2);
5151         }
5152
5153         // allocate textures as needed
5154         if (r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight)
5155         {
5156                 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
5157                 for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
5158                 {
5159                         if (p->texture_refraction)
5160                                 R_FreeTexture(p->texture_refraction);
5161                         p->texture_refraction = NULL;
5162                         if (p->texture_reflection)
5163                                 R_FreeTexture(p->texture_reflection);
5164                         p->texture_reflection = NULL;
5165                 }
5166                 memset(&r_waterstate, 0, sizeof(r_waterstate));
5167                 r_waterstate.texturewidth = texturewidth;
5168                 r_waterstate.textureheight = textureheight;
5169         }
5170
5171         if (r_waterstate.texturewidth)
5172         {
5173                 r_waterstate.enabled = true;
5174
5175                 // when doing a reduced render (HDR) we want to use a smaller area
5176                 r_waterstate.waterwidth = (int)bound(1, r_refdef.view.width * r_water_resolutionmultiplier.value, r_refdef.view.width);
5177                 r_waterstate.waterheight = (int)bound(1, r_refdef.view.height * r_water_resolutionmultiplier.value, r_refdef.view.height);
5178
5179                 // set up variables that will be used in shader setup
5180                 r_waterstate.screenscale[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
5181                 r_waterstate.screenscale[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
5182                 r_waterstate.screencenter[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
5183                 r_waterstate.screencenter[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
5184         }
5185
5186         r_waterstate.maxwaterplanes = MAX_WATERPLANES;
5187         r_waterstate.numwaterplanes = 0;
5188 }
5189
5190 void R_Water_AddWaterPlane(msurface_t *surface)
5191 {
5192         int triangleindex, planeindex;
5193         const int *e;
5194         vec3_t vert[3];
5195         vec3_t normal;
5196         vec3_t center;
5197         mplane_t plane;
5198         r_waterstate_waterplane_t *p;
5199         texture_t *t = R_GetCurrentTexture(surface->texture);
5200         // just use the first triangle with a valid normal for any decisions
5201         VectorClear(normal);
5202         for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
5203         {
5204                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
5205                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
5206                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
5207                 TriangleNormal(vert[0], vert[1], vert[2], normal);
5208                 if (VectorLength2(normal) >= 0.001)
5209                         break;
5210         }
5211
5212         VectorCopy(normal, plane.normal);
5213         VectorNormalize(plane.normal);
5214         plane.dist = DotProduct(vert[0], plane.normal);
5215         PlaneClassify(&plane);
5216         if (PlaneDiff(r_refdef.view.origin, &plane) < 0)
5217         {
5218                 // skip backfaces (except if nocullface is set)
5219                 if (!(t->currentmaterialflags & MATERIALFLAG_NOCULLFACE))
5220                         return;
5221                 VectorNegate(plane.normal, plane.normal);
5222                 plane.dist *= -1;
5223                 PlaneClassify(&plane);
5224         }
5225
5226
5227         // find a matching plane if there is one
5228         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
5229                 if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
5230                         break;
5231         if (planeindex >= r_waterstate.maxwaterplanes)
5232                 return; // nothing we can do, out of planes
5233
5234         // if this triangle does not fit any known plane rendered this frame, add one
5235         if (planeindex >= r_waterstate.numwaterplanes)
5236         {
5237                 // store the new plane
5238                 r_waterstate.numwaterplanes++;
5239                 p->plane = plane;
5240                 // clear materialflags and pvs
5241                 p->materialflags = 0;
5242                 p->pvsvalid = false;
5243         }
5244         // merge this surface's materialflags into the waterplane
5245         p->materialflags |= t->currentmaterialflags;
5246         // merge this surface's PVS into the waterplane
5247         VectorMAM(0.5f, surface->mins, 0.5f, surface->maxs, center);
5248         if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS
5249          && r_refdef.scene.worldmodel->brush.PointInLeaf && r_refdef.scene.worldmodel->brush.PointInLeaf(r_refdef.scene.worldmodel, center)->clusterindex >= 0)
5250         {
5251                 r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, center, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
5252                 p->pvsvalid = true;
5253         }
5254 }
5255
5256 static void R_Water_ProcessPlanes(void)
5257 {
5258         r_refdef_view_t originalview;
5259         r_refdef_view_t myview;
5260         int planeindex;
5261         r_waterstate_waterplane_t *p;
5262
5263         originalview = r_refdef.view;
5264
5265         // make sure enough textures are allocated
5266         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
5267         {
5268                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
5269                 {
5270                         if (!p->texture_refraction)
5271                                 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, NULL);
5272                         if (!p->texture_refraction)
5273                                 goto error;
5274                 }
5275
5276                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
5277                 {
5278                         if (!p->texture_reflection)
5279                                 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, NULL);
5280                         if (!p->texture_reflection)
5281                                 goto error;
5282                 }
5283         }
5284
5285         // render views
5286         r_refdef.view = originalview;
5287         r_refdef.view.showdebug = false;
5288         r_refdef.view.width = r_waterstate.waterwidth;
5289         r_refdef.view.height = r_waterstate.waterheight;
5290         r_refdef.view.useclipplane = true;
5291         myview = r_refdef.view;
5292         r_waterstate.renderingscene = true;
5293         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
5294         {
5295                 // render the normal view scene and copy into texture
5296                 // (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)
5297                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
5298                 {
5299                         r_refdef.view = myview;
5300                         r_refdef.view.clipplane = p->plane;
5301                         VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
5302                         r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
5303                         PlaneClassify(&r_refdef.view.clipplane);
5304
5305                         R_ResetViewRendering3D();
5306                         R_ClearScreen(r_refdef.fogenabled);
5307                         R_View_Update();
5308                         R_RenderScene();
5309
5310                         R_Mesh_CopyToTexture(R_GetTexture(p->texture_refraction), 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5311                 }
5312
5313                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
5314                 {
5315                         r_refdef.view = myview;
5316                         // render reflected scene and copy into texture
5317                         Matrix4x4_Reflect(&r_refdef.view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
5318                         // update the r_refdef.view.origin because otherwise the sky renders at the wrong location (amongst other problems)
5319                         Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, r_refdef.view.origin);
5320                         r_refdef.view.clipplane = p->plane;
5321                         // reverse the cullface settings for this render
5322                         r_refdef.view.cullface_front = GL_FRONT;
5323                         r_refdef.view.cullface_back = GL_BACK;
5324                         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.num_pvsclusterbytes)
5325                         {
5326                                 r_refdef.view.usecustompvs = true;
5327                                 if (p->pvsvalid)
5328                                         memcpy(r_refdef.viewcache.world_pvsbits, p->pvsbits, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
5329                                 else
5330                                         memset(r_refdef.viewcache.world_pvsbits, 0xFF, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
5331                         }
5332
5333                         R_ResetViewRendering3D();
5334                         R_ClearScreen(r_refdef.fogenabled);
5335                         R_View_Update();
5336                         R_RenderScene();
5337
5338                         R_Mesh_CopyToTexture(R_GetTexture(p->texture_reflection), 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5339                 }
5340         }
5341         r_waterstate.renderingscene = false;
5342         r_refdef.view = originalview;
5343         R_ResetViewRendering3D();
5344         R_ClearScreen(r_refdef.fogenabled);
5345         R_View_Update();
5346         return;
5347 error:
5348         r_refdef.view = originalview;
5349         r_waterstate.renderingscene = false;
5350         Cvar_SetValueQuick(&r_water, 0);
5351         Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed!  Turned off r_water.\n");
5352         return;
5353 }
5354
5355 void R_Bloom_StartFrame(void)
5356 {
5357         int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
5358
5359         switch(vid.renderpath)
5360         {
5361         case RENDERPATH_GL20:
5362         case RENDERPATH_CGGL:
5363                 break;
5364         case RENDERPATH_GL13:
5365         case RENDERPATH_GL11:
5366                 return;
5367         }
5368
5369         // set bloomwidth and bloomheight to the bloom resolution that will be
5370         // used (often less than the screen resolution for faster rendering)
5371         r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, vid.height);
5372         r_bloomstate.bloomheight = r_bloomstate.bloomwidth * vid.height / vid.width;
5373         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, vid.height);
5374         r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, (int)vid.maxtexturesize_2d);
5375         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, (int)vid.maxtexturesize_2d);
5376
5377         // calculate desired texture sizes
5378         if (vid.support.arb_texture_non_power_of_two)
5379         {
5380                 screentexturewidth = r_refdef.view.width;
5381                 screentextureheight = r_refdef.view.height;
5382                 bloomtexturewidth = r_bloomstate.bloomwidth;
5383                 bloomtextureheight = r_bloomstate.bloomheight;
5384         }
5385         else
5386         {
5387                 for (screentexturewidth  = 1;screentexturewidth  < vid.width               ;screentexturewidth  *= 2);
5388                 for (screentextureheight = 1;screentextureheight < vid.height              ;screentextureheight *= 2);
5389                 for (bloomtexturewidth   = 1;bloomtexturewidth   < r_bloomstate.bloomwidth ;bloomtexturewidth   *= 2);
5390                 for (bloomtextureheight  = 1;bloomtextureheight  < r_bloomstate.bloomheight;bloomtextureheight  *= 2);
5391         }
5392
5393         if ((r_hdr.integer || r_bloom.integer || (!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0))) && ((r_bloom_resolution.integer < 4 || r_bloom_blur.value < 1 || r_bloom_blur.value >= 512) || r_refdef.view.width > (int)vid.maxtexturesize_2d || r_refdef.view.height > (int)vid.maxtexturesize_2d))
5394         {
5395                 Cvar_SetValueQuick(&r_hdr, 0);
5396                 Cvar_SetValueQuick(&r_bloom, 0);
5397                 Cvar_SetValueQuick(&r_motionblur, 0);
5398                 Cvar_SetValueQuick(&r_damageblur, 0);
5399         }
5400
5401         if (!(r_glsl_postprocess.integer || (!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) || (v_glslgamma.integer && !vid_gammatables_trivial)) && !r_bloom.integer && !r_hdr.integer && (R_Stereo_Active() || (r_motionblur.value <= 0 && r_damageblur.value <= 0)))
5402                 screentexturewidth = screentextureheight = 0;
5403         if (!r_hdr.integer && !r_bloom.integer)
5404                 bloomtexturewidth = bloomtextureheight = 0;
5405
5406         // allocate textures as needed
5407         if (r_bloomstate.screentexturewidth != screentexturewidth || r_bloomstate.screentextureheight != screentextureheight)
5408         {
5409                 if (r_bloomstate.texture_screen)
5410                         R_FreeTexture(r_bloomstate.texture_screen);
5411                 r_bloomstate.texture_screen = NULL;
5412                 r_bloomstate.screentexturewidth = screentexturewidth;
5413                 r_bloomstate.screentextureheight = screentextureheight;
5414                 if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight)
5415                         r_bloomstate.texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", r_bloomstate.screentexturewidth, r_bloomstate.screentextureheight, NULL, TEXTYPE_BGRA, TEXF_FORCENEAREST | TEXF_CLAMP, NULL);
5416         }
5417         if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight)
5418         {
5419                 if (r_bloomstate.texture_bloom)
5420                         R_FreeTexture(r_bloomstate.texture_bloom);
5421                 r_bloomstate.texture_bloom = NULL;
5422                 r_bloomstate.bloomtexturewidth = bloomtexturewidth;
5423                 r_bloomstate.bloomtextureheight = bloomtextureheight;
5424                 if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight)
5425                         r_bloomstate.texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", r_bloomstate.bloomtexturewidth, r_bloomstate.bloomtextureheight, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP, NULL);
5426         }
5427
5428         // when doing a reduced render (HDR) we want to use a smaller area
5429         r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, r_refdef.view.height);
5430         r_bloomstate.bloomheight = r_bloomstate.bloomwidth * r_refdef.view.height / r_refdef.view.width;
5431         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_refdef.view.height);
5432         r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, r_bloomstate.bloomtexturewidth);
5433         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_bloomstate.bloomtextureheight);
5434
5435         // set up a texcoord array for the full resolution screen image
5436         // (we have to keep this around to copy back during final render)
5437         r_bloomstate.screentexcoord2f[0] = 0;
5438         r_bloomstate.screentexcoord2f[1] = (float)r_refdef.view.height    / (float)r_bloomstate.screentextureheight;
5439         r_bloomstate.screentexcoord2f[2] = (float)r_refdef.view.width     / (float)r_bloomstate.screentexturewidth;
5440         r_bloomstate.screentexcoord2f[3] = (float)r_refdef.view.height    / (float)r_bloomstate.screentextureheight;
5441         r_bloomstate.screentexcoord2f[4] = (float)r_refdef.view.width     / (float)r_bloomstate.screentexturewidth;
5442         r_bloomstate.screentexcoord2f[5] = 0;
5443         r_bloomstate.screentexcoord2f[6] = 0;
5444         r_bloomstate.screentexcoord2f[7] = 0;
5445
5446         // set up a texcoord array for the reduced resolution bloom image
5447         // (which will be additive blended over the screen image)
5448         r_bloomstate.bloomtexcoord2f[0] = 0;
5449         r_bloomstate.bloomtexcoord2f[1] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
5450         r_bloomstate.bloomtexcoord2f[2] = (float)r_bloomstate.bloomwidth  / (float)r_bloomstate.bloomtexturewidth;
5451         r_bloomstate.bloomtexcoord2f[3] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
5452         r_bloomstate.bloomtexcoord2f[4] = (float)r_bloomstate.bloomwidth  / (float)r_bloomstate.bloomtexturewidth;
5453         r_bloomstate.bloomtexcoord2f[5] = 0;
5454         r_bloomstate.bloomtexcoord2f[6] = 0;
5455         r_bloomstate.bloomtexcoord2f[7] = 0;
5456
5457         if (r_hdr.integer || r_bloom.integer)
5458         {
5459                 r_bloomstate.enabled = true;
5460                 r_bloomstate.hdr = r_hdr.integer != 0;
5461         }
5462
5463         R_Viewport_InitOrtho(&r_bloomstate.viewport, &identitymatrix, r_refdef.view.x, vid.height - r_bloomstate.bloomheight - r_refdef.view.y, r_bloomstate.bloomwidth, r_bloomstate.bloomheight, 0, 0, 1, 1, -10, 100, NULL);
5464 }
5465
5466 void R_Bloom_CopyBloomTexture(float colorscale)
5467 {
5468         r_refdef.stats.bloom++;
5469
5470         // scale down screen texture to the bloom texture size
5471         CHECKGLERROR
5472         R_SetViewport(&r_bloomstate.viewport);
5473         GL_BlendFunc(GL_ONE, GL_ZERO);
5474         GL_Color(colorscale, colorscale, colorscale, 1);
5475         // TODO: optimize with multitexture or GLSL
5476         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
5477         R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
5478         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5479         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5480
5481         // we now have a bloom image in the framebuffer
5482         // copy it into the bloom image texture for later processing
5483         R_Mesh_CopyToTexture(R_GetTexture(r_bloomstate.texture_bloom), 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);
5484         r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
5485 }
5486
5487 void R_Bloom_CopyHDRTexture(void)
5488 {
5489         R_Mesh_CopyToTexture(R_GetTexture(r_bloomstate.texture_bloom), 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5490         r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
5491 }
5492
5493 void R_Bloom_MakeTexture(void)
5494 {
5495         int x, range, dir;
5496         float xoffset, yoffset, r, brighten;
5497
5498         r_refdef.stats.bloom++;
5499
5500         R_ResetViewRendering2D();
5501         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5502         R_Mesh_ColorPointer(NULL, 0, 0);
5503
5504         // we have a bloom image in the framebuffer
5505         CHECKGLERROR
5506         R_SetViewport(&r_bloomstate.viewport);
5507
5508         for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
5509         {
5510                 x *= 2;
5511                 r = bound(0, r_bloom_colorexponent.value / x, 1);
5512                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
5513                 GL_Color(r, r, r, 1);
5514                 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
5515                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
5516                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5517                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5518
5519                 // copy the vertically blurred bloom view to a texture
5520                 GL_ActiveTexture(0);
5521                 CHECKGLERROR
5522                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);CHECKGLERROR
5523                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
5524         }
5525
5526         range = r_bloom_blur.integer * r_bloomstate.bloomwidth / 320;
5527         brighten = r_bloom_brighten.value;
5528         if (r_hdr.integer)
5529                 brighten *= r_hdr_range.value;
5530         brighten = sqrt(brighten);
5531         if(range >= 1)
5532                 brighten *= (3 * range) / (2 * range - 1); // compensate for the "dot particle"
5533         R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
5534         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.offsettexcoord2f, 0, 0);
5535
5536         for (dir = 0;dir < 2;dir++)
5537         {
5538                 // blend on at multiple vertical offsets to achieve a vertical blur
5539                 // TODO: do offset blends using GLSL
5540                 // TODO instead of changing the texcoords, change the target positions to prevent artifacts at edges
5541                 GL_BlendFunc(GL_ONE, GL_ZERO);
5542                 for (x = -range;x <= range;x++)
5543                 {
5544                         if (!dir){xoffset = 0;yoffset = x;}
5545                         else {xoffset = x;yoffset = 0;}
5546                         xoffset /= (float)r_bloomstate.bloomtexturewidth;
5547                         yoffset /= (float)r_bloomstate.bloomtextureheight;
5548                         // compute a texcoord array with the specified x and y offset
5549                         r_bloomstate.offsettexcoord2f[0] = xoffset+0;
5550                         r_bloomstate.offsettexcoord2f[1] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
5551                         r_bloomstate.offsettexcoord2f[2] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
5552                         r_bloomstate.offsettexcoord2f[3] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
5553                         r_bloomstate.offsettexcoord2f[4] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
5554                         r_bloomstate.offsettexcoord2f[5] = yoffset+0;
5555                         r_bloomstate.offsettexcoord2f[6] = xoffset+0;
5556                         r_bloomstate.offsettexcoord2f[7] = yoffset+0;
5557                         // this r value looks like a 'dot' particle, fading sharply to
5558                         // black at the edges
5559                         // (probably not realistic but looks good enough)
5560                         //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
5561                         //r = brighten/(range*2+1);
5562                         r = brighten / (range * 2 + 1);
5563                         if(range >= 1)
5564                                 r *= (1 - x*x/(float)(range*range));
5565                         GL_Color(r, r, r, 1);
5566                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5567                         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5568                         GL_BlendFunc(GL_ONE, GL_ONE);
5569                 }
5570
5571                 // copy the vertically blurred bloom view to a texture
5572                 GL_ActiveTexture(0);
5573                 CHECKGLERROR
5574                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);CHECKGLERROR
5575                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
5576         }
5577
5578         // apply subtract last
5579         // (just like it would be in a GLSL shader)
5580         if (r_bloom_colorsubtract.value > 0 && vid.support.ext_blend_subtract)
5581         {
5582                 GL_BlendFunc(GL_ONE, GL_ZERO);
5583                 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
5584                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
5585                 GL_Color(1, 1, 1, 1);
5586                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5587                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5588
5589                 GL_BlendFunc(GL_ONE, GL_ONE);
5590                 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
5591                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
5592                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
5593                 GL_Color(r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 1);
5594                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5595                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5596                 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
5597
5598                 // copy the darkened bloom view to a texture
5599                 R_Mesh_CopyToTexture(R_GetTexture(r_bloomstate.texture_bloom), 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);
5600                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
5601         }
5602 }
5603
5604 void R_HDR_RenderBloomTexture(void)
5605 {
5606         int oldwidth, oldheight;
5607         float oldcolorscale;
5608
5609         oldcolorscale = r_refdef.view.colorscale;
5610         oldwidth = r_refdef.view.width;
5611         oldheight = r_refdef.view.height;
5612         r_refdef.view.width = r_bloomstate.bloomwidth;
5613         r_refdef.view.height = r_bloomstate.bloomheight;
5614
5615         // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer?  it might improve SLI performance.
5616         // TODO: add exposure compensation features
5617         // TODO: add fp16 framebuffer support (using GL_EXT_framebuffer_object)
5618
5619         r_refdef.view.showdebug = false;
5620         r_refdef.view.colorscale *= r_bloom_colorscale.value / bound(1, r_hdr_range.value, 16);
5621
5622         R_ResetViewRendering3D();
5623
5624         R_ClearScreen(r_refdef.fogenabled);
5625         if (r_timereport_active)
5626                 R_TimeReport("HDRclear");
5627
5628         R_View_Update();
5629         if (r_timereport_active)
5630                 R_TimeReport("visibility");
5631
5632         // only do secondary renders with HDR if r_hdr is 2 or higher
5633         r_waterstate.numwaterplanes = 0;
5634         if (r_waterstate.enabled && r_hdr.integer >= 2)
5635                 R_RenderWaterPlanes();
5636
5637         r_refdef.view.showdebug = true;
5638         R_RenderScene();
5639         r_waterstate.numwaterplanes = 0;
5640
5641         R_ResetViewRendering2D();
5642
5643         R_Bloom_CopyHDRTexture();
5644         R_Bloom_MakeTexture();
5645
5646         // restore the view settings
5647         r_refdef.view.width = oldwidth;
5648         r_refdef.view.height = oldheight;
5649         r_refdef.view.colorscale = oldcolorscale;
5650         r_frame++; // used only by R_GetCurrentTexture
5651
5652         R_ResetViewRendering3D();
5653
5654         R_ClearScreen(r_refdef.fogenabled);
5655         if (r_timereport_active)
5656                 R_TimeReport("viewclear");
5657 }
5658
5659 static void R_BlendView(void)
5660 {
5661         unsigned int permutation;
5662         float uservecs[4][4];
5663
5664         switch (vid.renderpath)
5665         {
5666         case RENDERPATH_GL20:
5667         case RENDERPATH_CGGL:
5668                 permutation =
5669                           (r_bloomstate.texture_bloom ? SHADERPERMUTATION_BLOOM : 0)
5670                         | (r_refdef.viewblend[3] > 0 ? SHADERPERMUTATION_VIEWTINT : 0)
5671                         | ((v_glslgamma.value && !vid_gammatables_trivial) ? SHADERPERMUTATION_GAMMARAMPS : 0)
5672                         | (r_glsl_postprocess.integer ? SHADERPERMUTATION_POSTPROCESSING : 0)
5673                         | ((!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) ? SHADERPERMUTATION_SATURATION : 0);
5674
5675                 if (r_bloomstate.texture_screen)
5676                 {
5677                         // make sure the buffer is available
5678                         if (r_bloom_blur.value < 1) { Cvar_SetValueQuick(&r_bloom_blur, 1); }
5679
5680                         R_ResetViewRendering2D();
5681                         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5682                         R_Mesh_ColorPointer(NULL, 0, 0);
5683
5684                         if(!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0))
5685                         {
5686                                 // declare variables
5687                                 float speed;
5688                                 static float avgspeed;
5689
5690                                 speed = VectorLength(cl.movement_velocity);
5691
5692                                 cl.motionbluralpha = bound(0, (cl.time - cl.oldtime) / max(0.001, r_motionblur_vcoeff.value), 1);
5693                                 avgspeed = avgspeed * (1 - cl.motionbluralpha) + speed * cl.motionbluralpha;
5694
5695                                 speed = (avgspeed - r_motionblur_vmin.value) / max(1, r_motionblur_vmax.value - r_motionblur_vmin.value);
5696                                 speed = bound(0, speed, 1);
5697                                 speed = speed * (1 - r_motionblur_bmin.value) + r_motionblur_bmin.value;
5698
5699                                 // calculate values into a standard alpha
5700                                 cl.motionbluralpha = 1 - exp(-
5701                                                 (
5702                                                  (r_motionblur.value * speed / 80)
5703                                                  +
5704                                                  (r_damageblur.value * (cl.cshifts[CSHIFT_DAMAGE].percent / 1600))
5705                                                 )
5706                                                 /
5707                                                 max(0.0001, cl.time - cl.oldtime) // fps independent
5708                                            );
5709
5710                                 cl.motionbluralpha *= lhrandom(1 - r_motionblur_randomize.value, 1 + r_motionblur_randomize.value);
5711                                 cl.motionbluralpha = bound(0, cl.motionbluralpha, r_motionblur_maxblur.value);
5712                                 // apply the blur
5713                                 if (cl.motionbluralpha > 0)
5714                                 {
5715                                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5716                                         GL_Color(1, 1, 1, cl.motionbluralpha);
5717                                         R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
5718                                         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
5719                                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5720                                         r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
5721                                 }
5722                         }
5723
5724                         // copy view into the screen texture
5725                         R_Mesh_CopyToTexture(R_GetTexture(r_bloomstate.texture_screen), 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5726                         r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
5727                 }
5728                 else if (!r_bloomstate.texture_bloom)
5729                 {
5730                         // we may still have to do view tint...
5731                         if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
5732                         {
5733                                 // apply a color tint to the whole view
5734                                 R_ResetViewRendering2D();
5735                                 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5736                                 R_Mesh_ColorPointer(NULL, 0, 0);
5737                                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
5738                                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5739                                 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
5740                                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5741                         }
5742                         break; // no screen processing, no bloom, skip it
5743                 }
5744
5745                 if (r_bloomstate.texture_bloom && !r_bloomstate.hdr)
5746                 {
5747                         // render simple bloom effect
5748                         // copy the screen and shrink it and darken it for the bloom process
5749                         R_Bloom_CopyBloomTexture(r_bloom_colorscale.value);
5750                         // make the bloom texture
5751                         R_Bloom_MakeTexture();
5752                 }
5753
5754 #if _MSC_VER >= 1400
5755 #define sscanf sscanf_s
5756 #endif
5757                 memset(uservecs, 0, sizeof(uservecs));
5758                 sscanf(r_glsl_postprocess_uservec1.string, "%f %f %f %f", &uservecs[0][0], &uservecs[0][1], &uservecs[0][2], &uservecs[0][3]);
5759                 sscanf(r_glsl_postprocess_uservec2.string, "%f %f %f %f", &uservecs[1][0], &uservecs[1][1], &uservecs[1][2], &uservecs[1][3]);
5760                 sscanf(r_glsl_postprocess_uservec3.string, "%f %f %f %f", &uservecs[2][0], &uservecs[2][1], &uservecs[2][2], &uservecs[2][3]);
5761                 sscanf(r_glsl_postprocess_uservec4.string, "%f %f %f %f", &uservecs[3][0], &uservecs[3][1], &uservecs[3][2], &uservecs[3][3]);
5762
5763                 R_ResetViewRendering2D();
5764                 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5765                 R_Mesh_ColorPointer(NULL, 0, 0);
5766                 GL_Color(1, 1, 1, 1);
5767                 GL_BlendFunc(GL_ONE, GL_ZERO);
5768                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
5769                 R_Mesh_TexCoordPointer(1, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
5770
5771                 switch(vid.renderpath)
5772                 {
5773                 case RENDERPATH_GL20:
5774                         R_SetupShader_SetPermutationGLSL(SHADERMODE_POSTPROCESS, permutation);
5775                         if (r_glsl_permutation->loc_Texture_First      >= 0) R_Mesh_TexBind(GL20TU_FIRST     , R_GetTexture(r_bloomstate.texture_screen));
5776                         if (r_glsl_permutation->loc_Texture_Second     >= 0) R_Mesh_TexBind(GL20TU_SECOND    , R_GetTexture(r_bloomstate.texture_bloom ));
5777                         if (r_glsl_permutation->loc_Texture_GammaRamps >= 0) R_Mesh_TexBind(GL20TU_GAMMARAMPS, R_GetTexture(r_texture_gammaramps       ));
5778                         if (r_glsl_permutation->loc_ViewTintColor      >= 0) qglUniform4fARB(r_glsl_permutation->loc_ViewTintColor     , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
5779                         if (r_glsl_permutation->loc_ClientTime         >= 0) qglUniform1fARB(r_glsl_permutation->loc_ClientTime        , cl.time);
5780                         if (r_glsl_permutation->loc_PixelSize          >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelSize         , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);
5781                         if (r_glsl_permutation->loc_UserVec1           >= 0) qglUniform4fARB(r_glsl_permutation->loc_UserVec1          , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]);
5782                         if (r_glsl_permutation->loc_UserVec2           >= 0) qglUniform4fARB(r_glsl_permutation->loc_UserVec2          , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]);
5783                         if (r_glsl_permutation->loc_UserVec3           >= 0) qglUniform4fARB(r_glsl_permutation->loc_UserVec3          , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]);
5784                         if (r_glsl_permutation->loc_UserVec4           >= 0) qglUniform4fARB(r_glsl_permutation->loc_UserVec4          , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]);
5785                         if (r_glsl_permutation->loc_Saturation         >= 0) qglUniform1fARB(r_glsl_permutation->loc_Saturation        , r_glsl_saturation.value);
5786                         break;
5787                 case RENDERPATH_CGGL:
5788 #ifdef SUPPORTCG
5789                         R_SetupShader_SetPermutationCG(SHADERMODE_POSTPROCESS, permutation);
5790                         if (r_cg_permutation->fp_Texture_First     ) CG_BindTexture(r_cg_permutation->fp_Texture_First     , R_GetTexture(r_bloomstate.texture_screen));CHECKCGERROR
5791                         if (r_cg_permutation->fp_Texture_Second    ) CG_BindTexture(r_cg_permutation->fp_Texture_Second    , R_GetTexture(r_bloomstate.texture_bloom ));CHECKCGERROR
5792                         if (r_cg_permutation->fp_Texture_GammaRamps) CG_BindTexture(r_cg_permutation->fp_Texture_GammaRamps, R_GetTexture(r_texture_gammaramps       ));CHECKCGERROR
5793                         if (r_cg_permutation->fp_ViewTintColor     ) cgGLSetParameter4f(     r_cg_permutation->fp_ViewTintColor     , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);CHECKCGERROR
5794                         if (r_cg_permutation->fp_ClientTime        ) cgGLSetParameter1f(     r_cg_permutation->fp_ClientTime        , cl.time);CHECKCGERROR
5795                         if (r_cg_permutation->fp_PixelSize         ) cgGLSetParameter2f(     r_cg_permutation->fp_PixelSize         , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);CHECKCGERROR
5796                         if (r_cg_permutation->fp_UserVec1          ) cgGLSetParameter4f(     r_cg_permutation->fp_UserVec1          , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]);CHECKCGERROR
5797                         if (r_cg_permutation->fp_UserVec2          ) cgGLSetParameter4f(     r_cg_permutation->fp_UserVec2          , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]);CHECKCGERROR
5798                         if (r_cg_permutation->fp_UserVec3          ) cgGLSetParameter4f(     r_cg_permutation->fp_UserVec3          , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]);CHECKCGERROR
5799                         if (r_cg_permutation->fp_UserVec4          ) cgGLSetParameter4f(     r_cg_permutation->fp_UserVec4          , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]);CHECKCGERROR
5800                         if (r_cg_permutation->fp_Saturation        ) cgGLSetParameter1f(     r_cg_permutation->fp_Saturation        , r_glsl_saturation.value);CHECKCGERROR
5801 #endif
5802                         break;
5803                 default:
5804                         break;
5805                 }
5806                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5807                 r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
5808                 break;
5809         case RENDERPATH_GL13:
5810         case RENDERPATH_GL11:
5811                 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
5812                 {
5813                         // apply a color tint to the whole view
5814                         R_ResetViewRendering2D();
5815                         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5816                         R_Mesh_ColorPointer(NULL, 0, 0);
5817                         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
5818                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5819                         GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
5820                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5821                 }
5822                 break;
5823         }
5824 }
5825
5826 matrix4x4_t r_waterscrollmatrix;
5827
5828 void R_UpdateFogColor(void) // needs to be called before HDR subrender too, as that changes colorscale!
5829 {
5830         if (r_refdef.fog_density)
5831         {
5832                 r_refdef.fogcolor[0] = r_refdef.fog_red;
5833                 r_refdef.fogcolor[1] = r_refdef.fog_green;
5834                 r_refdef.fogcolor[2] = r_refdef.fog_blue;
5835
5836                 Vector4Set(r_refdef.fogplane, 0, 0, 1, -r_refdef.fog_height);
5837                 r_refdef.fogplaneviewdist = DotProduct(r_refdef.fogplane, r_refdef.view.origin) + r_refdef.fogplane[3];
5838                 r_refdef.fogplaneviewabove = r_refdef.fogplaneviewdist >= 0;
5839                 r_refdef.fogheightfade = -0.5f/max(0.125f, r_refdef.fog_fadedepth);
5840
5841                 {
5842                         vec3_t fogvec;
5843                         VectorCopy(r_refdef.fogcolor, fogvec);
5844                         //   color.rgb *= ContrastBoost * SceneBrightness;
5845                         VectorScale(fogvec, r_refdef.view.colorscale, fogvec);
5846                         r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
5847                         r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
5848                         r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
5849                 }
5850         }
5851 }
5852
5853 void R_UpdateVariables(void)
5854 {
5855         R_Textures_Frame();
5856
5857         r_refdef.scene.ambient = r_ambient.value * (1.0f / 64.0f);
5858
5859         r_refdef.farclip = r_farclip_base.value;
5860         if (r_refdef.scene.worldmodel)
5861                 r_refdef.farclip += r_refdef.scene.worldmodel->radius * r_farclip_world.value * 2;
5862         r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
5863
5864         if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
5865                 Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
5866         r_refdef.polygonfactor = 0;
5867         r_refdef.polygonoffset = 0;
5868         r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
5869         r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
5870
5871         r_refdef.scene.rtworld = r_shadow_realtime_world.integer != 0;
5872         r_refdef.scene.rtworldshadows = r_shadow_realtime_world_shadows.integer && vid.stencil;
5873         r_refdef.scene.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer;
5874         r_refdef.scene.rtdlightshadows = r_refdef.scene.rtdlight && r_shadow_realtime_dlight_shadows.integer && vid.stencil;
5875         r_refdef.lightmapintensity = r_refdef.scene.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
5876         if (r_showsurfaces.integer)
5877         {
5878                 r_refdef.scene.rtworld = false;
5879                 r_refdef.scene.rtworldshadows = false;
5880                 r_refdef.scene.rtdlight = false;
5881                 r_refdef.scene.rtdlightshadows = false;
5882                 r_refdef.lightmapintensity = 0;
5883         }
5884
5885         if (gamemode == GAME_NEHAHRA)
5886         {
5887                 if (gl_fogenable.integer)
5888                 {
5889                         r_refdef.oldgl_fogenable = true;
5890                         r_refdef.fog_density = gl_fogdensity.value;
5891                         r_refdef.fog_red = gl_fogred.value;
5892                         r_refdef.fog_green = gl_foggreen.value;
5893                         r_refdef.fog_blue = gl_fogblue.value;
5894                         r_refdef.fog_alpha = 1;
5895                         r_refdef.fog_start = 0;
5896                         r_refdef.fog_end = gl_skyclip.value;
5897                         r_refdef.fog_height = 1<<30;
5898                         r_refdef.fog_fadedepth = 128;
5899                 }
5900                 else if (r_refdef.oldgl_fogenable)
5901                 {
5902                         r_refdef.oldgl_fogenable = false;
5903                         r_refdef.fog_density = 0;
5904                         r_refdef.fog_red = 0;
5905                         r_refdef.fog_green = 0;
5906                         r_refdef.fog_blue = 0;
5907                         r_refdef.fog_alpha = 0;
5908                         r_refdef.fog_start = 0;
5909                         r_refdef.fog_end = 0;
5910                         r_refdef.fog_height = 1<<30;
5911                         r_refdef.fog_fadedepth = 128;
5912                 }
5913         }
5914
5915         r_refdef.fog_alpha = bound(0, r_refdef.fog_alpha, 1);
5916         r_refdef.fog_start = max(0, r_refdef.fog_start);
5917         r_refdef.fog_end = max(r_refdef.fog_start + 0.01, r_refdef.fog_end);
5918
5919         // R_UpdateFogColor(); // why? R_RenderScene does it anyway
5920
5921         if (r_refdef.fog_density && r_drawfog.integer)
5922         {
5923                 r_refdef.fogenabled = true;
5924                 // this is the point where the fog reaches 0.9986 alpha, which we
5925                 // consider a good enough cutoff point for the texture
5926                 // (0.9986 * 256 == 255.6)
5927                 if (r_fog_exp2.integer)
5928                         r_refdef.fogrange = 32 / (r_refdef.fog_density * r_refdef.fog_density) + r_refdef.fog_start;
5929                 else
5930                         r_refdef.fogrange = 2048 / r_refdef.fog_density + r_refdef.fog_start;
5931                 r_refdef.fogrange = bound(r_refdef.fog_start, r_refdef.fogrange, r_refdef.fog_end);
5932                 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
5933                 r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
5934                 // fog color was already set
5935                 // update the fog texture
5936                 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)
5937                         R_BuildFogTexture();
5938         }
5939         else
5940                 r_refdef.fogenabled = false;
5941
5942         switch(vid.renderpath)
5943         {
5944         case RENDERPATH_GL20:
5945         case RENDERPATH_CGGL:
5946                 if(v_glslgamma.integer && !vid_gammatables_trivial)
5947                 {
5948                         if(!r_texture_gammaramps || vid_gammatables_serial != r_texture_gammaramps_serial)
5949                         {
5950                                 // build GLSL gamma texture
5951 #define RAMPWIDTH 256
5952                                 unsigned short ramp[RAMPWIDTH * 3];
5953                                 unsigned char rampbgr[RAMPWIDTH][4];
5954                                 int i;
5955
5956                                 r_texture_gammaramps_serial = vid_gammatables_serial;
5957
5958                                 VID_BuildGammaTables(&ramp[0], RAMPWIDTH);
5959                                 for(i = 0; i < RAMPWIDTH; ++i)
5960                                 {
5961                                         rampbgr[i][0] = (unsigned char) (ramp[i + 2 * RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
5962                                         rampbgr[i][1] = (unsigned char) (ramp[i + RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
5963                                         rampbgr[i][2] = (unsigned char) (ramp[i] * 255.0 / 65535.0 + 0.5);
5964                                         rampbgr[i][3] = 0;
5965                                 }
5966                                 if (r_texture_gammaramps)
5967                                 {
5968                                         R_UpdateTexture(r_texture_gammaramps, &rampbgr[0][0], 0, 0, RAMPWIDTH, 1);
5969                                 }
5970                                 else
5971                                 {
5972                                         r_texture_gammaramps = R_LoadTexture2D(r_main_texturepool, "gammaramps", RAMPWIDTH, 1, &rampbgr[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT | TEXF_ALLOWUPDATES, NULL);
5973                                 }
5974                         }
5975                 }
5976                 else
5977                 {
5978                         // remove GLSL gamma texture
5979                 }
5980                 break;
5981         case RENDERPATH_GL13:
5982         case RENDERPATH_GL11:
5983                 break;
5984         }
5985 }
5986
5987 static r_refdef_scene_type_t r_currentscenetype = RST_CLIENT;
5988 static r_refdef_scene_t r_scenes_store[ RST_COUNT ];
5989 /*
5990 ================
5991 R_SelectScene
5992 ================
5993 */
5994 void R_SelectScene( r_refdef_scene_type_t scenetype ) {
5995         if( scenetype != r_currentscenetype ) {
5996                 // store the old scenetype
5997                 r_scenes_store[ r_currentscenetype ] = r_refdef.scene;
5998                 r_currentscenetype = scenetype;
5999                 // move in the new scene
6000                 r_refdef.scene = r_scenes_store[ r_currentscenetype ];
6001         }
6002 }
6003
6004 /*
6005 ================
6006 R_GetScenePointer
6007 ================
6008 */
6009 r_refdef_scene_t * R_GetScenePointer( r_refdef_scene_type_t scenetype )
6010 {
6011         // of course, we could also add a qboolean that provides a lock state and a ReleaseScenePointer function..
6012         if( scenetype == r_currentscenetype ) {
6013                 return &r_refdef.scene;
6014         } else {
6015                 return &r_scenes_store[ scenetype ];
6016         }
6017 }
6018
6019 /*
6020 ================
6021 R_RenderView
6022 ================
6023 */
6024 void R_RenderView(void)
6025 {
6026         if (r_timereport_active)
6027                 R_TimeReport("start");
6028         r_frame++; // used only by R_GetCurrentTexture
6029         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
6030
6031         if (!r_drawentities.integer)
6032                 r_refdef.scene.numentities = 0;
6033
6034         R_AnimCache_ClearCache();
6035         R_FrameData_NewFrame();
6036
6037         if (r_refdef.view.isoverlay)
6038         {
6039                 // TODO: FIXME: move this into its own backend function maybe? [2/5/2008 Andreas]
6040                 GL_Clear( GL_DEPTH_BUFFER_BIT );
6041                 R_TimeReport("depthclear");
6042
6043                 r_refdef.view.showdebug = false;
6044
6045                 r_waterstate.enabled = false;
6046                 r_waterstate.numwaterplanes = 0;
6047
6048                 R_RenderScene();
6049
6050                 CHECKGLERROR
6051                 return;
6052         }
6053
6054         if (!r_refdef.scene.entities || r_refdef.view.width * r_refdef.view.height == 0 || !r_renderview.integer/* || !r_refdef.scene.worldmodel*/)
6055                 return; //Host_Error ("R_RenderView: NULL worldmodel");
6056
6057         r_refdef.view.colorscale = r_hdr_scenebrightness.value;
6058
6059         // break apart the view matrix into vectors for various purposes
6060         // it is important that this occurs outside the RenderScene function because that can be called from reflection renders, where the vectors come out wrong
6061         // however the r_refdef.view.origin IS updated in RenderScene intentionally - otherwise the sky renders at the wrong origin, etc
6062         Matrix4x4_ToVectors(&r_refdef.view.matrix, r_refdef.view.forward, r_refdef.view.left, r_refdef.view.up, r_refdef.view.origin);
6063         VectorNegate(r_refdef.view.left, r_refdef.view.right);
6064         // make an inverted copy of the view matrix for tracking sprites
6065         Matrix4x4_Invert_Simple(&r_refdef.view.inverse_matrix, &r_refdef.view.matrix);
6066
6067         R_Shadow_UpdateWorldLightSelection();
6068
6069         R_Bloom_StartFrame();
6070         R_Water_StartFrame();
6071
6072         CHECKGLERROR
6073         if (r_timereport_active)
6074                 R_TimeReport("viewsetup");
6075
6076         R_ResetViewRendering3D();
6077
6078         if (r_refdef.view.clear || r_refdef.fogenabled)
6079         {
6080                 R_ClearScreen(r_refdef.fogenabled);
6081                 if (r_timereport_active)
6082                         R_TimeReport("viewclear");
6083         }
6084         r_refdef.view.clear = true;
6085
6086         // this produces a bloom texture to be used in R_BlendView() later
6087         if (r_hdr.integer && r_bloomstate.bloomwidth)
6088                 R_HDR_RenderBloomTexture();
6089
6090         r_refdef.view.showdebug = true;
6091
6092         R_View_Update();
6093         if (r_timereport_active)
6094                 R_TimeReport("visibility");
6095
6096         r_waterstate.numwaterplanes = 0;
6097         if (r_waterstate.enabled)
6098                 R_RenderWaterPlanes();
6099
6100         R_RenderScene();
6101         r_waterstate.numwaterplanes = 0;
6102
6103         R_BlendView();
6104         if (r_timereport_active)
6105                 R_TimeReport("blendview");
6106
6107         GL_Scissor(0, 0, vid.width, vid.height);
6108         GL_ScissorTest(false);
6109         CHECKGLERROR
6110 }
6111
6112 void R_RenderWaterPlanes(void)
6113 {
6114         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawAddWaterPlanes)
6115         {
6116                 r_refdef.scene.worldmodel->DrawAddWaterPlanes(r_refdef.scene.worldentity);
6117                 if (r_timereport_active)
6118                         R_TimeReport("waterworld");
6119         }
6120
6121         // don't let sound skip if going slow
6122         if (r_refdef.scene.extraupdate)
6123                 S_ExtraUpdate ();
6124
6125         R_DrawModelsAddWaterPlanes();
6126         if (r_timereport_active)
6127                 R_TimeReport("watermodels");
6128
6129         if (r_waterstate.numwaterplanes)
6130         {
6131                 R_Water_ProcessPlanes();
6132                 if (r_timereport_active)
6133                         R_TimeReport("waterscenes");
6134         }
6135 }
6136
6137 extern void R_DrawLightningBeams (void);
6138 extern void VM_CL_AddPolygonsToMeshQueue (void);
6139 extern void R_DrawPortals (void);
6140 extern cvar_t cl_locs_show;
6141 static void R_DrawLocs(void);
6142 static void R_DrawEntityBBoxes(void);
6143 static void R_DrawModelDecals(void);
6144 extern cvar_t cl_decals_newsystem;
6145 extern qboolean r_shadow_usingdeferredprepass;
6146 void R_RenderScene(void)
6147 {
6148         r_refdef.stats.renders++;
6149
6150         R_UpdateFogColor();
6151
6152         // don't let sound skip if going slow
6153         if (r_refdef.scene.extraupdate)
6154                 S_ExtraUpdate ();
6155
6156         R_MeshQueue_BeginScene();
6157
6158         R_SkyStartFrame();
6159
6160         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);
6161
6162         if (cl.csqc_vidvars.drawworld)
6163         {
6164                 // don't let sound skip if going slow
6165                 if (r_refdef.scene.extraupdate)
6166                         S_ExtraUpdate ();
6167
6168                 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawSky)
6169                 {
6170                         r_refdef.scene.worldmodel->DrawSky(r_refdef.scene.worldentity);
6171                         if (r_timereport_active)
6172                                 R_TimeReport("worldsky");
6173                 }
6174
6175                 if (R_DrawBrushModelsSky() && r_timereport_active)
6176                         R_TimeReport("bmodelsky");
6177
6178                 if (skyrendermasked && skyrenderlater)
6179                 {
6180                         // we have to force off the water clipping plane while rendering sky
6181                         R_SetupView(false);
6182                         R_Sky();
6183                         R_SetupView(true);
6184                         if (r_timereport_active)
6185                                 R_TimeReport("sky");
6186                 }
6187         }
6188
6189         R_AnimCache_CacheVisibleEntities();
6190         if (r_timereport_active)
6191                 R_TimeReport("animation");
6192
6193         R_Shadow_PrepareLights();
6194         if (r_timereport_active)
6195                 R_TimeReport("preparelights");
6196
6197         if (r_shadow_usingdeferredprepass)
6198                 R_Shadow_DrawPrepass();
6199
6200         if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawDepth)
6201         {
6202                 r_refdef.scene.worldmodel->DrawDepth(r_refdef.scene.worldentity);
6203                 if (r_timereport_active)
6204                         R_TimeReport("worlddepth");
6205         }
6206         if (r_depthfirst.integer >= 2)
6207         {
6208                 R_DrawModelsDepth();
6209                 if (r_timereport_active)
6210                         R_TimeReport("modeldepth");
6211         }
6212
6213         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->Draw)
6214         {
6215                 r_refdef.scene.worldmodel->Draw(r_refdef.scene.worldentity);
6216                 if (r_timereport_active)
6217                         R_TimeReport("world");
6218         }
6219
6220         // don't let sound skip if going slow
6221         if (r_refdef.scene.extraupdate)
6222                 S_ExtraUpdate ();
6223
6224         R_DrawModels();
6225         if (r_timereport_active)
6226                 R_TimeReport("models");
6227
6228         // don't let sound skip if going slow
6229         if (r_refdef.scene.extraupdate)
6230                 S_ExtraUpdate ();
6231
6232         if (r_shadows.integer > 0 && !r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
6233         {
6234                 R_DrawModelShadows();
6235                 R_ResetViewRendering3D();
6236                 // don't let sound skip if going slow
6237                 if (r_refdef.scene.extraupdate)
6238                         S_ExtraUpdate ();
6239         }
6240
6241         if (!r_shadow_usingdeferredprepass)
6242         {
6243                 R_Shadow_DrawLights();
6244                 if (r_timereport_active)
6245                         R_TimeReport("rtlights");
6246         }
6247
6248         // don't let sound skip if going slow
6249         if (r_refdef.scene.extraupdate)
6250                 S_ExtraUpdate ();
6251
6252         if (r_shadows.integer > 0 && r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
6253         {
6254                 R_DrawModelShadows();
6255                 R_ResetViewRendering3D();
6256                 // don't let sound skip if going slow
6257                 if (r_refdef.scene.extraupdate)
6258                         S_ExtraUpdate ();
6259         }
6260
6261         if (cl.csqc_vidvars.drawworld)
6262         {
6263                 if (cl_decals_newsystem.integer)
6264                 {
6265                         R_DrawModelDecals();
6266                         if (r_timereport_active)
6267                                 R_TimeReport("modeldecals");
6268                 }
6269                 else
6270                 {
6271                         R_DrawDecals();
6272                         if (r_timereport_active)
6273                                 R_TimeReport("decals");
6274                 }
6275
6276                 R_DrawParticles();
6277                 if (r_timereport_active)
6278                         R_TimeReport("particles");
6279
6280                 R_DrawExplosions();
6281                 if (r_timereport_active)
6282                         R_TimeReport("explosions");
6283
6284                 R_DrawLightningBeams();
6285                 if (r_timereport_active)
6286                         R_TimeReport("lightning");
6287         }
6288
6289         VM_CL_AddPolygonsToMeshQueue();
6290
6291         if (r_refdef.view.showdebug)
6292         {
6293                 if (cl_locs_show.integer)
6294                 {
6295                         R_DrawLocs();
6296                         if (r_timereport_active)
6297                                 R_TimeReport("showlocs");
6298                 }
6299
6300                 if (r_drawportals.integer)
6301                 {
6302                         R_DrawPortals();
6303                         if (r_timereport_active)
6304                                 R_TimeReport("portals");
6305                 }
6306
6307                 if (r_showbboxes.value > 0)
6308                 {
6309                         R_DrawEntityBBoxes();
6310                         if (r_timereport_active)
6311                                 R_TimeReport("bboxes");
6312                 }
6313         }
6314
6315         R_MeshQueue_RenderTransparent();
6316         if (r_timereport_active)
6317                 R_TimeReport("drawtrans");
6318
6319         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))
6320         {
6321                 r_refdef.scene.worldmodel->DrawDebug(r_refdef.scene.worldentity);
6322                 if (r_timereport_active)
6323                         R_TimeReport("worlddebug");
6324                 R_DrawModelsDebug();
6325                 if (r_timereport_active)
6326                         R_TimeReport("modeldebug");
6327         }
6328
6329         if (cl.csqc_vidvars.drawworld)
6330         {
6331                 R_Shadow_DrawCoronas();
6332                 if (r_timereport_active)
6333                         R_TimeReport("coronas");
6334         }
6335
6336         // don't let sound skip if going slow
6337         if (r_refdef.scene.extraupdate)
6338                 S_ExtraUpdate ();
6339
6340         R_ResetViewRendering2D();
6341 }
6342
6343 static const unsigned short bboxelements[36] =
6344 {
6345         5, 1, 3, 5, 3, 7,
6346         6, 2, 0, 6, 0, 4,
6347         7, 3, 2, 7, 2, 6,
6348         4, 0, 1, 4, 1, 5,
6349         4, 5, 7, 4, 7, 6,
6350         1, 0, 2, 1, 2, 3,
6351 };
6352
6353 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
6354 {
6355         int i;
6356         float *v, *c, f1, f2, vertex3f[8*3], color4f[8*4];
6357
6358         RSurf_ActiveWorldEntity();
6359
6360         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6361         GL_DepthMask(false);
6362         GL_DepthRange(0, 1);
6363         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
6364         R_Mesh_ResetTextureState();
6365
6366         vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; //
6367         vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
6368         vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
6369         vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
6370         vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
6371         vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
6372         vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
6373         vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
6374         R_FillColors(color4f, 8, cr, cg, cb, ca);
6375         if (r_refdef.fogenabled)
6376         {
6377                 for (i = 0, v = vertex3f, c = color4f;i < 8;i++, v += 3, c += 4)
6378                 {
6379                         f1 = RSurf_FogVertex(v);
6380                         f2 = 1 - f1;
6381                         c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
6382                         c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
6383                         c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
6384                 }
6385         }
6386         R_Mesh_VertexPointer(vertex3f, 0, 0);
6387         R_Mesh_ColorPointer(color4f, 0, 0);
6388         R_Mesh_ResetTextureState();
6389         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
6390         R_Mesh_Draw(0, 8, 0, 12, NULL, bboxelements, 0, 0);
6391 }
6392
6393 static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
6394 {
6395         int i;
6396         float color[4];
6397         prvm_edict_t *edict;
6398         prvm_prog_t *prog_save = prog;
6399
6400         // this function draws bounding boxes of server entities
6401         if (!sv.active)
6402                 return;
6403
6404         GL_CullFace(GL_NONE);
6405         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
6406
6407         prog = 0;
6408         SV_VM_Begin();
6409         for (i = 0;i < numsurfaces;i++)
6410         {
6411                 edict = PRVM_EDICT_NUM(surfacelist[i]);
6412                 switch ((int)edict->fields.server->solid)
6413                 {
6414                         case SOLID_NOT:      Vector4Set(color, 1, 1, 1, 0.05);break;
6415                         case SOLID_TRIGGER:  Vector4Set(color, 1, 0, 1, 0.10);break;
6416                         case SOLID_BBOX:     Vector4Set(color, 0, 1, 0, 0.10);break;
6417                         case SOLID_SLIDEBOX: Vector4Set(color, 1, 0, 0, 0.10);break;
6418                         case SOLID_BSP:      Vector4Set(color, 0, 0, 1, 0.05);break;
6419                         default:             Vector4Set(color, 0, 0, 0, 0.50);break;
6420                 }
6421                 color[3] *= r_showbboxes.value;
6422                 color[3] = bound(0, color[3], 1);
6423                 GL_DepthTest(!r_showdisabledepthtest.integer);
6424                 GL_CullFace(r_refdef.view.cullface_front);
6425                 R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
6426         }
6427         SV_VM_End();
6428         prog = prog_save;
6429 }
6430
6431 static void R_DrawEntityBBoxes(void)
6432 {
6433         int i;
6434         prvm_edict_t *edict;
6435         vec3_t center;
6436         prvm_prog_t *prog_save = prog;
6437
6438         // this function draws bounding boxes of server entities
6439         if (!sv.active)
6440                 return;
6441
6442         prog = 0;
6443         SV_VM_Begin();
6444         for (i = 0;i < prog->num_edicts;i++)
6445         {
6446                 edict = PRVM_EDICT_NUM(i);
6447                 if (edict->priv.server->free)
6448                         continue;
6449                 // exclude the following for now, as they don't live in world coordinate space and can't be solid:
6450                 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.tag_entity)->edict != 0)
6451                         continue;
6452                 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.viewmodelforclient)->edict != 0)
6453                         continue;
6454                 VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
6455                 R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
6456         }
6457         SV_VM_End();
6458         prog = prog_save;
6459 }
6460
6461 static const int nomodelelement3i[24] =
6462 {
6463         5, 2, 0,
6464         5, 1, 2,
6465         5, 0, 3,
6466         5, 3, 1,
6467         0, 2, 4,
6468         2, 1, 4,
6469         3, 0, 4,
6470         1, 3, 4
6471 };
6472
6473 static const unsigned short nomodelelement3s[24] =
6474 {
6475         5, 2, 0,
6476         5, 1, 2,
6477         5, 0, 3,
6478         5, 3, 1,
6479         0, 2, 4,
6480         2, 1, 4,
6481         3, 0, 4,
6482         1, 3, 4
6483 };
6484
6485 static const float nomodelvertex3f[6*3] =
6486 {
6487         -16,   0,   0,
6488          16,   0,   0,
6489           0, -16,   0,
6490           0,  16,   0,
6491           0,   0, -16,
6492           0,   0,  16
6493 };
6494
6495 static const float nomodelcolor4f[6*4] =
6496 {
6497         0.0f, 0.0f, 0.5f, 1.0f,
6498         0.0f, 0.0f, 0.5f, 1.0f,
6499         0.0f, 0.5f, 0.0f, 1.0f,
6500         0.0f, 0.5f, 0.0f, 1.0f,
6501         0.5f, 0.0f, 0.0f, 1.0f,
6502         0.5f, 0.0f, 0.0f, 1.0f
6503 };
6504
6505 void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
6506 {
6507         int i;
6508         float f1, f2, *c;
6509         float color4f[6*4];
6510
6511         RSurf_ActiveCustomEntity(&ent->matrix, &ent->inversematrix, ent->flags, ent->shadertime, ent->colormod[0], ent->colormod[1], ent->colormod[2], ent->alpha, 6, nomodelvertex3f, NULL, NULL, NULL, NULL, nomodelcolor4f, 8, nomodelelement3i, nomodelelement3s, false, false);
6512
6513         // this is only called once per entity so numsurfaces is always 1, and
6514         // surfacelist is always {0}, so this code does not handle batches
6515
6516         if (rsurface.ent_flags & RENDER_ADDITIVE)
6517         {
6518                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
6519                 GL_DepthMask(false);
6520         }
6521         else if (rsurface.colormod[3] < 1)
6522         {
6523                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6524                 GL_DepthMask(false);
6525         }
6526         else
6527         {
6528                 GL_BlendFunc(GL_ONE, GL_ZERO);
6529                 GL_DepthMask(true);
6530         }
6531         GL_DepthRange(0, (rsurface.ent_flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
6532         GL_PolygonOffset(rsurface.basepolygonfactor, rsurface.basepolygonoffset);
6533         GL_DepthTest(!(rsurface.ent_flags & RENDER_NODEPTHTEST));
6534         GL_CullFace((rsurface.ent_flags & RENDER_DOUBLESIDED) ? GL_NONE : r_refdef.view.cullface_back);
6535         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
6536         R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
6537         memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
6538         R_Mesh_ColorPointer(color4f, 0, 0);
6539         for (i = 0, c = color4f;i < 6;i++, c += 4)
6540         {
6541                 c[0] *= rsurface.colormod[0];
6542                 c[1] *= rsurface.colormod[1];
6543                 c[2] *= rsurface.colormod[2];
6544                 c[3] *= rsurface.colormod[3];
6545         }
6546         if (r_refdef.fogenabled)
6547         {
6548                 for (i = 0, c = color4f;i < 6;i++, c += 4)
6549                 {
6550                         f1 = RSurf_FogVertex(rsurface.vertex3f + 3*i);
6551                         f2 = 1 - f1;
6552                         c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
6553                         c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
6554                         c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
6555                 }
6556         }
6557         R_Mesh_ResetTextureState();
6558         R_Mesh_Draw(0, 6, 0, 8, nomodelelement3i, nomodelelement3s, 0, 0);
6559 }
6560
6561 void R_DrawNoModel(entity_render_t *ent)
6562 {
6563         vec3_t org;
6564         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
6565         if ((ent->flags & RENDER_ADDITIVE) || (ent->alpha < 1))
6566                 R_MeshQueue_AddTransparent(ent->flags & RENDER_NODEPTHTEST ? r_refdef.view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
6567         else
6568                 R_DrawNoModel_TransparentCallback(ent, rsurface.rtlight, 0, NULL);
6569 }
6570
6571 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
6572 {
6573         vec3_t right1, right2, diff, normal;
6574
6575         VectorSubtract (org2, org1, normal);
6576
6577         // calculate 'right' vector for start
6578         VectorSubtract (r_refdef.view.origin, org1, diff);
6579         CrossProduct (normal, diff, right1);
6580         VectorNormalize (right1);
6581
6582         // calculate 'right' vector for end
6583         VectorSubtract (r_refdef.view.origin, org2, diff);
6584         CrossProduct (normal, diff, right2);
6585         VectorNormalize (right2);
6586
6587         vert[ 0] = org1[0] + width * right1[0];
6588         vert[ 1] = org1[1] + width * right1[1];
6589         vert[ 2] = org1[2] + width * right1[2];
6590         vert[ 3] = org1[0] - width * right1[0];
6591         vert[ 4] = org1[1] - width * right1[1];
6592         vert[ 5] = org1[2] - width * right1[2];
6593         vert[ 6] = org2[0] - width * right2[0];
6594         vert[ 7] = org2[1] - width * right2[1];
6595         vert[ 8] = org2[2] - width * right2[2];
6596         vert[ 9] = org2[0] + width * right2[0];
6597         vert[10] = org2[1] + width * right2[1];
6598         vert[11] = org2[2] + width * right2[2];
6599 }
6600
6601 void R_CalcSprite_Vertex3f(float *vertex3f, const vec3_t origin, const vec3_t left, const vec3_t up, float scalex1, float scalex2, float scaley1, float scaley2)
6602 {
6603         vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
6604         vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
6605         vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
6606         vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
6607         vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
6608         vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
6609         vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
6610         vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
6611         vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
6612         vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
6613         vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
6614         vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
6615 }
6616
6617 int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
6618 {
6619         int i;
6620         float *vertex3f;
6621         float v[3];
6622         VectorSet(v, x, y, z);
6623         for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
6624                 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
6625                         break;
6626         if (i == mesh->numvertices)
6627         {
6628                 if (mesh->numvertices < mesh->maxvertices)
6629                 {
6630                         VectorCopy(v, vertex3f);
6631                         mesh->numvertices++;
6632                 }
6633                 return mesh->numvertices;
6634         }
6635         else
6636                 return i;
6637 }
6638
6639 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
6640 {
6641         int i;
6642         int *e, element[3];
6643         element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
6644         element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
6645         e = mesh->element3i + mesh->numtriangles * 3;
6646         for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
6647         {
6648                 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
6649                 if (mesh->numtriangles < mesh->maxtriangles)
6650                 {
6651                         *e++ = element[0];
6652                         *e++ = element[1];
6653                         *e++ = element[2];
6654                         mesh->numtriangles++;
6655                 }
6656                 element[1] = element[2];
6657         }
6658 }
6659
6660 void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
6661 {
6662         int i;
6663         int *e, element[3];
6664         element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
6665         element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
6666         e = mesh->element3i + mesh->numtriangles * 3;
6667         for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
6668         {
6669                 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
6670                 if (mesh->numtriangles < mesh->maxtriangles)
6671                 {
6672                         *e++ = element[0];
6673                         *e++ = element[1];
6674                         *e++ = element[2];
6675                         mesh->numtriangles++;
6676                 }
6677                 element[1] = element[2];
6678         }
6679 }
6680
6681 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
6682 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
6683 {
6684         int planenum, planenum2;
6685         int w;
6686         int tempnumpoints;
6687         mplane_t *plane, *plane2;
6688         double maxdist;
6689         double temppoints[2][256*3];
6690         // figure out how large a bounding box we need to properly compute this brush
6691         maxdist = 0;
6692         for (w = 0;w < numplanes;w++)
6693                 maxdist = max(maxdist, fabs(planes[w].dist));
6694         // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
6695         maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
6696         for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
6697         {
6698                 w = 0;
6699                 tempnumpoints = 4;
6700                 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
6701                 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
6702                 {
6703                         if (planenum2 == planenum)
6704                                 continue;
6705                         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);
6706                         w = !w;
6707                 }
6708                 if (tempnumpoints < 3)
6709                         continue;
6710                 // generate elements forming a triangle fan for this polygon
6711                 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
6712         }
6713 }
6714
6715 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)
6716 {
6717         texturelayer_t *layer;
6718         layer = t->currentlayers + t->currentnumlayers++;
6719         layer->type = type;
6720         layer->depthmask = depthmask;
6721         layer->blendfunc1 = blendfunc1;
6722         layer->blendfunc2 = blendfunc2;
6723         layer->texture = texture;
6724         layer->texmatrix = *matrix;
6725         layer->color[0] = r;
6726         layer->color[1] = g;
6727         layer->color[2] = b;
6728         layer->color[3] = a;
6729 }
6730
6731 static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
6732 {
6733         double index, f;
6734         index = parms[2] + r_refdef.scene.time * parms[3];
6735         index -= floor(index);
6736         switch (func)
6737         {
6738         default:
6739         case Q3WAVEFUNC_NONE:
6740         case Q3WAVEFUNC_NOISE:
6741         case Q3WAVEFUNC_COUNT:
6742                 f = 0;
6743                 break;
6744         case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
6745         case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
6746         case Q3WAVEFUNC_SAWTOOTH: f = index;break;
6747         case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
6748         case Q3WAVEFUNC_TRIANGLE:
6749                 index *= 4;
6750                 f = index - floor(index);
6751                 if (index < 1)
6752                         f = f;
6753                 else if (index < 2)
6754                         f = 1 - f;
6755                 else if (index < 3)
6756                         f = -f;
6757                 else
6758                         f = -(1 - f);
6759                 break;
6760         }
6761         return (float)(parms[0] + parms[1] * f);
6762 }
6763
6764 void R_tcMod_ApplyToMatrix(matrix4x4_t *texmatrix, q3shaderinfo_layer_tcmod_t *tcmod, int currentmaterialflags)
6765 {
6766         int w, h, idx;
6767         float f;
6768         float tcmat[12];
6769         matrix4x4_t matrix, temp;
6770         switch(tcmod->tcmod)
6771         {
6772                 case Q3TCMOD_COUNT:
6773                 case Q3TCMOD_NONE:
6774                         if (currentmaterialflags & MATERIALFLAG_WATERSCROLL)
6775                                 matrix = r_waterscrollmatrix;
6776                         else
6777                                 matrix = identitymatrix;
6778                         break;
6779                 case Q3TCMOD_ENTITYTRANSLATE:
6780                         // this is used in Q3 to allow the gamecode to control texcoord
6781                         // scrolling on the entity, which is not supported in darkplaces yet.
6782                         Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
6783                         break;
6784                 case Q3TCMOD_ROTATE:
6785                         Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
6786                         Matrix4x4_ConcatRotate(&matrix, tcmod->parms[0] * r_refdef.scene.time, 0, 0, 1);
6787                         Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
6788                         break;
6789                 case Q3TCMOD_SCALE:
6790                         Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
6791                         break;
6792                 case Q3TCMOD_SCROLL:
6793                         Matrix4x4_CreateTranslate(&matrix, tcmod->parms[0] * r_refdef.scene.time, tcmod->parms[1] * r_refdef.scene.time, 0);
6794                         break;
6795                 case Q3TCMOD_PAGE: // poor man's animmap (to store animations into a single file, useful for HTTP downloaded textures)
6796                         w = (int) tcmod->parms[0];
6797                         h = (int) tcmod->parms[1];
6798                         f = r_refdef.scene.time / (tcmod->parms[2] * w * h);
6799                         f = f - floor(f);
6800                         idx = (int) floor(f * w * h);
6801                         Matrix4x4_CreateTranslate(&matrix, (idx % w) / tcmod->parms[0], (idx / w) / tcmod->parms[1], 0);
6802                         break;
6803                 case Q3TCMOD_STRETCH:
6804                         f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
6805                         Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
6806                         break;
6807                 case Q3TCMOD_TRANSFORM:
6808                         VectorSet(tcmat +  0, tcmod->parms[0], tcmod->parms[1], 0);
6809                         VectorSet(tcmat +  3, tcmod->parms[2], tcmod->parms[3], 0);
6810                         VectorSet(tcmat +  6, 0                   , 0                , 1);
6811                         VectorSet(tcmat +  9, tcmod->parms[4], tcmod->parms[5], 0);
6812                         Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
6813                         break;
6814                 case Q3TCMOD_TURBULENT:
6815                         // this is handled in the RSurf_PrepareVertices function
6816                         matrix = identitymatrix;
6817                         break;
6818         }
6819         temp = *texmatrix;
6820         Matrix4x4_Concat(texmatrix, &matrix, &temp);
6821 }
6822
6823 void R_LoadQWSkin(r_qwskincache_t *cache, const char *skinname)
6824 {
6825         int textureflags = (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_PICMIP | TEXF_COMPRESS;
6826         char name[MAX_QPATH];
6827         skinframe_t *skinframe;
6828         unsigned char pixels[296*194];
6829         strlcpy(cache->name, skinname, sizeof(cache->name));
6830         dpsnprintf(name, sizeof(name), "skins/%s.pcx", cache->name);
6831         if (developer_loading.integer)
6832                 Con_Printf("loading %s\n", name);
6833         skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
6834         if (!skinframe || !skinframe->base)
6835         {
6836                 unsigned char *f;
6837                 fs_offset_t filesize;
6838                 skinframe = NULL;
6839                 f = FS_LoadFile(name, tempmempool, true, &filesize);
6840                 if (f)
6841                 {
6842                         if (LoadPCX_QWSkin(f, filesize, pixels, 296, 194))
6843                                 skinframe = R_SkinFrame_LoadInternalQuake(name, textureflags, true, r_fullbrights.integer, pixels, image_width, image_height);
6844                         Mem_Free(f);
6845                 }
6846         }
6847         cache->skinframe = skinframe;
6848 }
6849
6850 texture_t *R_GetCurrentTexture(texture_t *t)
6851 {
6852         int i;
6853         const entity_render_t *ent = rsurface.entity;
6854         dp_model_t *model = ent->model;
6855         q3shaderinfo_layer_tcmod_t *tcmod;
6856
6857         if (t->update_lastrenderframe == r_frame && t->update_lastrenderentity == (void *)ent)
6858                 return t->currentframe;
6859         t->update_lastrenderframe = r_frame;
6860         t->update_lastrenderentity = (void *)ent;
6861
6862         // switch to an alternate material if this is a q1bsp animated material
6863         {
6864                 texture_t *texture = t;
6865                 int s = rsurface.ent_skinnum;
6866                 if ((unsigned int)s >= (unsigned int)model->numskins)
6867                         s = 0;
6868                 if (model->skinscenes)
6869                 {
6870                         if (model->skinscenes[s].framecount > 1)
6871                                 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.scene.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
6872                         else
6873                                 s = model->skinscenes[s].firstframe;
6874                 }
6875                 if (s > 0)
6876                         t = t + s * model->num_surfaces;
6877                 if (t->animated)
6878                 {
6879                         // use an alternate animation if the entity's frame is not 0,
6880                         // and only if the texture has an alternate animation
6881                         if (rsurface.ent_alttextures && t->anim_total[1])
6882                                 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[1]) : 0];
6883                         else
6884                                 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[0]) : 0];
6885                 }
6886                 texture->currentframe = t;
6887         }
6888
6889         // update currentskinframe to be a qw skin or animation frame
6890         if (rsurface.ent_qwskin >= 0)
6891         {
6892                 i = rsurface.ent_qwskin;
6893                 if (!r_qwskincache || r_qwskincache_size != cl.maxclients)
6894                 {
6895                         r_qwskincache_size = cl.maxclients;
6896                         if (r_qwskincache)
6897                                 Mem_Free(r_qwskincache);
6898                         r_qwskincache = Mem_Alloc(r_main_mempool, sizeof(*r_qwskincache) * r_qwskincache_size);
6899                 }
6900                 if (strcmp(r_qwskincache[i].name, cl.scores[i].qw_skin))
6901                         R_LoadQWSkin(&r_qwskincache[i], cl.scores[i].qw_skin);
6902                 t->currentskinframe = r_qwskincache[i].skinframe;
6903                 if (t->currentskinframe == NULL)
6904                         t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
6905         }
6906         else if (t->numskinframes >= 2)
6907                 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
6908         if (t->backgroundnumskinframes >= 2)
6909                 t->backgroundcurrentskinframe = t->backgroundskinframes[(int)(t->backgroundskinframerate * (cl.time - rsurface.ent_shadertime)) % t->backgroundnumskinframes];
6910
6911         t->currentmaterialflags = t->basematerialflags;
6912         t->currentalpha = rsurface.colormod[3];
6913         if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
6914                 t->currentalpha *= r_wateralpha.value;
6915         if(t->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay)
6916                 t->currentalpha *= t->r_water_wateralpha;
6917         if(!r_waterstate.enabled || r_refdef.view.isoverlay)
6918                 t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION);
6919         if (!(rsurface.ent_flags & RENDER_LIGHT))
6920                 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
6921         else if (rsurface.modeltexcoordlightmap2f == NULL && !(t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
6922         {
6923                 // pick a model lighting mode
6924                 if (VectorLength2(rsurface.modellight_diffuse) >= (1.0f / 256.0f))
6925                         t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
6926                 else
6927                         t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
6928         }
6929         if (rsurface.ent_flags & RENDER_ADDITIVE)
6930                 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
6931         else if (t->currentalpha < 1)
6932                 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
6933         if (rsurface.ent_flags & RENDER_DOUBLESIDED)
6934                 t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
6935         if (rsurface.ent_flags & (RENDER_NODEPTHTEST | RENDER_VIEWMODEL))
6936                 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
6937         if (t->backgroundnumskinframes)
6938                 t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
6939         if (t->currentmaterialflags & MATERIALFLAG_BLENDED)
6940         {
6941                 if (t->currentmaterialflags & (MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER))
6942                         t->currentmaterialflags &= ~MATERIALFLAG_BLENDED;
6943         }
6944         else
6945                 t->currentmaterialflags &= ~(MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER);
6946         if ((t->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST)) == MATERIALFLAG_BLENDED && r_transparentdepthmasking.integer && !(t->basematerialflags & MATERIALFLAG_BLENDED))
6947                 t->currentmaterialflags |= MATERIALFLAG_TRANSDEPTH;
6948
6949         // there is no tcmod
6950         if (t->currentmaterialflags & MATERIALFLAG_WATERSCROLL)
6951         {
6952                 t->currenttexmatrix = r_waterscrollmatrix;
6953                 t->currentbackgroundtexmatrix = r_waterscrollmatrix;
6954         }
6955         else if (!(t->currentmaterialflags & MATERIALFLAG_CUSTOMSURFACE))
6956         {
6957                 Matrix4x4_CreateIdentity(&t->currenttexmatrix);
6958                 Matrix4x4_CreateIdentity(&t->currentbackgroundtexmatrix);
6959         }
6960
6961         for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
6962                 R_tcMod_ApplyToMatrix(&t->currenttexmatrix, tcmod, t->currentmaterialflags);
6963         for (i = 0, tcmod = t->backgroundtcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
6964                 R_tcMod_ApplyToMatrix(&t->currentbackgroundtexmatrix, tcmod, t->currentmaterialflags);
6965
6966         t->colormapping = VectorLength2(rsurface.colormap_pantscolor) + VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f);
6967         if (t->currentskinframe->qpixels)
6968                 R_SkinFrame_GenerateTexturesFromQPixels(t->currentskinframe, t->colormapping);
6969         t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
6970         t->pantstexture = t->colormapping ? t->currentskinframe->pants : NULL;
6971         t->shirttexture = t->colormapping ? t->currentskinframe->shirt : NULL;
6972         t->nmaptexture = t->currentskinframe->nmap;
6973         t->glosstexture = r_texture_black;
6974         t->glowtexture = t->currentskinframe->glow;
6975         t->fogtexture = t->currentskinframe->fog;
6976         if (t->backgroundnumskinframes)
6977         {
6978                 t->backgroundbasetexture = (!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base;
6979                 t->backgroundnmaptexture = t->backgroundcurrentskinframe->nmap;
6980                 t->backgroundglosstexture = r_texture_black;
6981                 t->backgroundglowtexture = t->backgroundcurrentskinframe->glow;
6982         }
6983         else
6984         {
6985                 t->backgroundbasetexture = t->backgroundnumskinframes ? ((!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base) : r_texture_white;
6986                 t->backgroundnmaptexture = r_texture_blanknormalmap;
6987                 t->backgroundglosstexture = r_texture_black;
6988                 t->backgroundglowtexture = NULL;
6989         }
6990         t->specularpower = r_shadow_glossexponent.value;
6991         // TODO: store reference values for these in the texture?
6992         t->specularscale = 0;
6993         if (r_shadow_gloss.integer > 0)
6994         {
6995                 if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
6996                 {
6997                         if (r_shadow_glossintensity.value > 0)
6998                         {
6999                                 t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
7000                                 t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
7001                                 t->specularscale = r_shadow_glossintensity.value;
7002                         }
7003                 }
7004                 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
7005                 {
7006                         t->glosstexture = r_texture_white;
7007                         t->backgroundglosstexture = r_texture_white;
7008                         t->specularscale = r_shadow_gloss2intensity.value;
7009                         t->specularpower = r_shadow_gloss2exponent.value;
7010                 }
7011         }
7012         t->specularscale *= t->specularscalemod;
7013         t->specularpower *= t->specularpowermod;
7014
7015         // lightmaps mode looks bad with dlights using actual texturing, so turn
7016         // off the colormap and glossmap, but leave the normalmap on as it still
7017         // accurately represents the shading involved
7018         if (gl_lightmaps.integer)
7019         {
7020                 t->basetexture = r_texture_grey128;
7021                 t->pantstexture = r_texture_black;
7022                 t->shirttexture = r_texture_black;
7023                 t->nmaptexture = r_texture_blanknormalmap;
7024                 t->glosstexture = r_texture_black;
7025                 t->glowtexture = NULL;
7026                 t->fogtexture = NULL;
7027                 t->backgroundbasetexture = NULL;
7028                 t->backgroundnmaptexture = r_texture_blanknormalmap;
7029                 t->backgroundglosstexture = r_texture_black;
7030                 t->backgroundglowtexture = NULL;
7031                 t->specularscale = 0;
7032                 t->currentmaterialflags = MATERIALFLAG_WALL | (t->currentmaterialflags & (MATERIALFLAG_NOCULLFACE | MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SHORTDEPTHRANGE));
7033         }
7034
7035         Vector4Set(t->lightmapcolor, rsurface.colormod[0], rsurface.colormod[1], rsurface.colormod[2], t->currentalpha);
7036         VectorClear(t->dlightcolor);
7037         t->currentnumlayers = 0;
7038         if (t->currentmaterialflags & MATERIALFLAG_WALL)
7039         {
7040                 int blendfunc1, blendfunc2;
7041                 qboolean depthmask;
7042                 if (t->currentmaterialflags & MATERIALFLAG_ADD)
7043                 {
7044                         blendfunc1 = GL_SRC_ALPHA;
7045                         blendfunc2 = GL_ONE;
7046                 }
7047                 else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
7048                 {
7049                         blendfunc1 = GL_SRC_ALPHA;
7050                         blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
7051                 }
7052                 else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
7053                 {
7054                         blendfunc1 = t->customblendfunc[0];
7055                         blendfunc2 = t->customblendfunc[1];
7056                 }
7057                 else
7058                 {
7059                         blendfunc1 = GL_ONE;
7060                         blendfunc2 = GL_ZERO;
7061                 }
7062                 depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
7063                 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
7064                 {
7065                         // fullbright is not affected by r_refdef.lightmapintensity
7066                         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]);
7067                         if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
7068                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->pantstexture, &t->currenttexmatrix, rsurface.colormap_pantscolor[0] * t->lightmapcolor[0], rsurface.colormap_pantscolor[1] * t->lightmapcolor[1], rsurface.colormap_pantscolor[2] * t->lightmapcolor[2], t->lightmapcolor[3]);
7069                         if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
7070                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->shirttexture, &t->currenttexmatrix, rsurface.colormap_shirtcolor[0] * t->lightmapcolor[0], rsurface.colormap_shirtcolor[1] * t->lightmapcolor[1], rsurface.colormap_shirtcolor[2] * t->lightmapcolor[2], t->lightmapcolor[3]);
7071                 }
7072                 else
7073                 {
7074                         vec3_t ambientcolor;
7075                         float colorscale;
7076                         // set the color tint used for lights affecting this surface
7077                         VectorSet(t->dlightcolor, t->lightmapcolor[0] * t->lightmapcolor[3], t->lightmapcolor[1] * t->lightmapcolor[3], t->lightmapcolor[2] * t->lightmapcolor[3]);
7078                         colorscale = 2;
7079                         // q3bsp has no lightmap updates, so the lightstylevalue that
7080                         // would normally be baked into the lightmap must be
7081                         // applied to the color
7082                         // FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
7083                         if (model->type == mod_brushq3)
7084                                 colorscale *= r_refdef.scene.rtlightstylevalue[0];
7085                         colorscale *= r_refdef.lightmapintensity;
7086                         VectorScale(t->lightmapcolor, r_refdef.scene.ambient, ambientcolor);
7087                         VectorScale(t->lightmapcolor, colorscale, t->lightmapcolor);
7088                         // basic lit geometry
7089                         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]);
7090                         // add pants/shirt if needed
7091                         if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
7092                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->pantstexture, &t->currenttexmatrix, rsurface.colormap_pantscolor[0] * t->lightmapcolor[0], rsurface.colormap_pantscolor[1] * t->lightmapcolor[1], rsurface.colormap_pantscolor[2]  * t->lightmapcolor[2], t->lightmapcolor[3]);
7093                         if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
7094                                 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->shirttexture, &t->currenttexmatrix, rsurface.colormap_shirtcolor[0] * t->lightmapcolor[0], rsurface.colormap_shirtcolor[1] * t->lightmapcolor[1], rsurface.colormap_shirtcolor[2] * t->lightmapcolor[2], t->lightmapcolor[3]);
7095                         // now add ambient passes if needed
7096                         if (VectorLength2(ambientcolor) >= (1.0f/1048576.0f))
7097                         {
7098                                 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]);
7099                                 if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
7100                                         R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->pantstexture, &t->currenttexmatrix, rsurface.colormap_pantscolor[0] * ambientcolor[0], rsurface.colormap_pantscolor[1] * ambientcolor[1], rsurface.colormap_pantscolor[2] * ambientcolor[2], t->lightmapcolor[3]);
7101                                 if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
7102                                         R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->shirttexture, &t->currenttexmatrix, rsurface.colormap_shirtcolor[0] * ambientcolor[0], rsurface.colormap_shirtcolor[1] * ambientcolor[1], rsurface.colormap_shirtcolor[2] * ambientcolor[2], t->lightmapcolor[3]);
7103                         }
7104                 }
7105                 if (t->glowtexture != NULL && !gl_lightmaps.integer)
7106                         R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->glowtexture, &t->currenttexmatrix, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2], t->lightmapcolor[3]);
7107                 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
7108                 {
7109                         // if this is opaque use alpha blend which will darken the earlier
7110                         // passes cheaply.
7111                         //
7112                         // if this is an alpha blended material, all the earlier passes
7113                         // were darkened by fog already, so we only need to add the fog
7114                         // color ontop through the fog mask texture
7115                         //
7116                         // if this is an additive blended material, all the earlier passes
7117                         // were darkened by fog already, and we should not add fog color
7118                         // (because the background was not darkened, there is no fog color
7119                         // that was lost behind it).
7120                         R_Texture_AddLayer(t, false, GL_SRC_ALPHA, (t->currentmaterialflags & MATERIALFLAG_BLENDED) ? GL_ONE : GL_ONE_MINUS_SRC_ALPHA, TEXTURELAYERTYPE_FOG, t->fogtexture, &t->currenttexmatrix, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], t->lightmapcolor[3]);
7121                 }
7122         }
7123
7124         return t->currentframe;
7125 }
7126
7127 rsurfacestate_t rsurface;
7128
7129 void R_Mesh_ResizeArrays(int newvertices)
7130 {
7131         float *base;
7132         if (rsurface.array_size >= newvertices)
7133                 return;
7134         if (rsurface.array_modelvertex3f)
7135                 Mem_Free(rsurface.array_modelvertex3f);
7136         rsurface.array_size = (newvertices + 1023) & ~1023;
7137         base = (float *)Mem_Alloc(r_main_mempool, rsurface.array_size * sizeof(float[33]));
7138         rsurface.array_modelvertex3f     = base + rsurface.array_size * 0;
7139         rsurface.array_modelsvector3f    = base + rsurface.array_size * 3;
7140         rsurface.array_modeltvector3f    = base + rsurface.array_size * 6;
7141         rsurface.array_modelnormal3f     = base + rsurface.array_size * 9;
7142         rsurface.array_deformedvertex3f  = base + rsurface.array_size * 12;
7143         rsurface.array_deformedsvector3f = base + rsurface.array_size * 15;
7144         rsurface.array_deformedtvector3f = base + rsurface.array_size * 18;
7145         rsurface.array_deformednormal3f  = base + rsurface.array_size * 21;
7146         rsurface.array_texcoord3f        = base + rsurface.array_size * 24;
7147         rsurface.array_color4f           = base + rsurface.array_size * 27;
7148         rsurface.array_generatedtexcoordtexture2f = base + rsurface.array_size * 31;
7149 }
7150
7151 void RSurf_ActiveWorldEntity(void)
7152 {
7153         dp_model_t *model = r_refdef.scene.worldmodel;
7154         //if (rsurface.entity == r_refdef.scene.worldentity)
7155         //      return;
7156         rsurface.entity = r_refdef.scene.worldentity;
7157         rsurface.skeleton = NULL;
7158         rsurface.ent_skinnum = 0;
7159         rsurface.ent_qwskin = -1;
7160         rsurface.ent_shadertime = 0;
7161         rsurface.ent_flags = r_refdef.scene.worldentity->flags;
7162         if (rsurface.array_size < model->surfmesh.num_vertices)
7163                 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
7164         rsurface.matrix = identitymatrix;
7165         rsurface.inversematrix = identitymatrix;
7166         rsurface.matrixscale = 1;
7167         rsurface.inversematrixscale = 1;
7168         R_EntityMatrix(&identitymatrix);
7169         VectorCopy(r_refdef.view.origin, rsurface.localvieworigin);
7170         Vector4Copy(r_refdef.fogplane, rsurface.fogplane);
7171         rsurface.fograngerecip = r_refdef.fograngerecip;
7172         rsurface.fogheightfade = r_refdef.fogheightfade;
7173         rsurface.fogplaneviewdist = r_refdef.fogplaneviewdist;
7174         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
7175         VectorSet(rsurface.modellight_ambient, 0, 0, 0);
7176         VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
7177         VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
7178         VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
7179         VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
7180         VectorSet(rsurface.colormod, r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale);
7181         rsurface.colormod[3] = 1;
7182         VectorSet(rsurface.glowmod, r_refdef.view.colorscale * r_hdr_glowintensity.value, r_refdef.view.colorscale * r_hdr_glowintensity.value, r_refdef.view.colorscale * r_hdr_glowintensity.value);
7183         memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
7184         rsurface.frameblend[0].lerp = 1;
7185         rsurface.ent_alttextures = false;
7186         rsurface.basepolygonfactor = r_refdef.polygonfactor;
7187         rsurface.basepolygonoffset = r_refdef.polygonoffset;
7188         rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
7189         rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
7190         rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
7191         rsurface.modelsvector3f = model->surfmesh.data_svector3f;
7192         rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
7193         rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
7194         rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
7195         rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
7196         rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
7197         rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
7198         rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
7199         rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
7200         rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
7201         rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
7202         rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
7203         rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
7204         rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
7205         rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
7206         rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
7207         rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
7208         rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
7209         rsurface.modelelement3i = model->surfmesh.data_element3i;
7210         rsurface.modelelement3s = model->surfmesh.data_element3s;
7211         rsurface.modelelement3i_bufferobject = model->surfmesh.ebo3i;
7212         rsurface.modelelement3s_bufferobject = model->surfmesh.ebo3s;
7213         rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
7214         rsurface.modelnum_vertices = model->surfmesh.num_vertices;
7215         rsurface.modelnum_triangles = model->surfmesh.num_triangles;
7216         rsurface.modelsurfaces = model->data_surfaces;
7217         rsurface.generatedvertex = false;
7218         rsurface.vertex3f  = rsurface.modelvertex3f;
7219         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
7220         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
7221         rsurface.svector3f = rsurface.modelsvector3f;
7222         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
7223         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
7224         rsurface.tvector3f = rsurface.modeltvector3f;
7225         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
7226         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
7227         rsurface.normal3f  = rsurface.modelnormal3f;
7228         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
7229         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
7230         rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
7231 }
7232
7233 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents, qboolean prepass)
7234 {
7235         dp_model_t *model = ent->model;
7236         //if (rsurface.entity == ent && (!model->surfmesh.isanimated || (!wantnormals && !wanttangents)))
7237         //      return;
7238         rsurface.entity = (entity_render_t *)ent;
7239         rsurface.skeleton = ent->skeleton;
7240         rsurface.ent_skinnum = ent->skinnum;
7241         rsurface.ent_qwskin = (ent->entitynumber <= cl.maxclients && ent->entitynumber >= 1 && cls.protocol == PROTOCOL_QUAKEWORLD && cl.scores[ent->entitynumber - 1].qw_skin[0] && !strcmp(ent->model->name, "progs/player.mdl")) ? (ent->entitynumber - 1) : -1;
7242         rsurface.ent_shadertime = ent->shadertime;
7243         rsurface.ent_flags = ent->flags;
7244         if (rsurface.array_size < model->surfmesh.num_vertices)
7245                 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
7246         rsurface.matrix = ent->matrix;
7247         rsurface.inversematrix = ent->inversematrix;
7248         rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
7249         rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
7250         R_EntityMatrix(&rsurface.matrix);
7251         Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
7252         Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
7253         rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
7254         rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
7255         rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
7256         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
7257         VectorCopy(ent->modellight_ambient, rsurface.modellight_ambient);
7258         VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
7259         VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
7260         VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
7261         VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
7262         VectorScale(ent->colormod, r_refdef.view.colorscale, rsurface.colormod);
7263         rsurface.colormod[3] = ent->alpha;
7264         VectorScale(ent->glowmod, r_refdef.view.colorscale * r_hdr_glowintensity.value, rsurface.glowmod);
7265         memcpy(rsurface.frameblend, ent->frameblend, sizeof(ent->frameblend));
7266         rsurface.ent_alttextures = ent->framegroupblend[0].frame != 0;
7267         rsurface.basepolygonfactor = r_refdef.polygonfactor;
7268         rsurface.basepolygonoffset = r_refdef.polygonoffset;
7269         if (ent->model->brush.submodel && !prepass)
7270         {
7271                 rsurface.basepolygonfactor += r_polygonoffset_submodel_factor.value;
7272                 rsurface.basepolygonoffset += r_polygonoffset_submodel_offset.value;
7273         }
7274         if (model->surfmesh.isanimated && model->AnimateVertices && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].subframe != 0))
7275         {
7276                 if (ent->animcache_vertex3f && !r_framedata_failed)
7277                 {
7278                         rsurface.modelvertex3f = ent->animcache_vertex3f;
7279                         rsurface.modelsvector3f = wanttangents ? ent->animcache_svector3f : NULL;
7280                         rsurface.modeltvector3f = wanttangents ? ent->animcache_tvector3f : NULL;
7281                         rsurface.modelnormal3f = wantnormals ? ent->animcache_normal3f : NULL;
7282                 }
7283                 else if (wanttangents)
7284                 {
7285                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
7286                         rsurface.modelsvector3f = rsurface.array_modelsvector3f;
7287                         rsurface.modeltvector3f = rsurface.array_modeltvector3f;
7288                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
7289                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f);
7290                 }
7291                 else if (wantnormals)
7292                 {
7293                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
7294                         rsurface.modelsvector3f = NULL;
7295                         rsurface.modeltvector3f = NULL;
7296                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
7297                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL);
7298                 }
7299                 else
7300                 {
7301                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
7302                         rsurface.modelsvector3f = NULL;
7303                         rsurface.modeltvector3f = NULL;
7304                         rsurface.modelnormal3f = NULL;
7305                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, NULL, NULL, NULL);
7306                 }
7307                 rsurface.modelvertex3f_bufferobject = 0;
7308                 rsurface.modelvertex3f_bufferoffset = 0;
7309                 rsurface.modelsvector3f_bufferobject = 0;
7310                 rsurface.modelsvector3f_bufferoffset = 0;
7311                 rsurface.modeltvector3f_bufferobject = 0;
7312                 rsurface.modeltvector3f_bufferoffset = 0;
7313                 rsurface.modelnormal3f_bufferobject = 0;
7314                 rsurface.modelnormal3f_bufferoffset = 0;
7315                 rsurface.generatedvertex = true;
7316         }
7317         else
7318         {
7319                 rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
7320                 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
7321                 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
7322                 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
7323                 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
7324                 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
7325                 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
7326                 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
7327                 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
7328                 rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
7329                 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
7330                 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
7331                 rsurface.generatedvertex = false;
7332         }
7333         rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
7334         rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
7335         rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
7336         rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
7337         rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
7338         rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
7339         rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
7340         rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
7341         rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
7342         rsurface.modelelement3i = model->surfmesh.data_element3i;
7343         rsurface.modelelement3s = model->surfmesh.data_element3s;
7344         rsurface.modelelement3i_bufferobject = model->surfmesh.ebo3i;
7345         rsurface.modelelement3s_bufferobject = model->surfmesh.ebo3s;
7346         rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
7347         rsurface.modelnum_vertices = model->surfmesh.num_vertices;
7348         rsurface.modelnum_triangles = model->surfmesh.num_triangles;
7349         rsurface.modelsurfaces = model->data_surfaces;
7350         rsurface.vertex3f  = rsurface.modelvertex3f;
7351         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
7352         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
7353         rsurface.svector3f = rsurface.modelsvector3f;
7354         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
7355         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
7356         rsurface.tvector3f = rsurface.modeltvector3f;
7357         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
7358         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
7359         rsurface.normal3f  = rsurface.modelnormal3f;
7360         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
7361         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
7362         rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
7363 }
7364
7365 void RSurf_ActiveCustomEntity(const matrix4x4_t *matrix, const matrix4x4_t *inversematrix, int entflags, double shadertime, float r, float g, float b, float a, int numvertices, const float *vertex3f, const float *texcoord2f, const float *normal3f, const float *svector3f, const float *tvector3f, const float *color4f, int numtriangles, const int *element3i, const unsigned short *element3s, qboolean wantnormals, qboolean wanttangents)
7366 {
7367         rsurface.entity = r_refdef.scene.worldentity;
7368         rsurface.skeleton = NULL;
7369         rsurface.ent_skinnum = 0;
7370         rsurface.ent_qwskin = -1;
7371         rsurface.ent_shadertime = shadertime;
7372         rsurface.ent_flags = entflags;
7373         rsurface.modelnum_vertices = numvertices;
7374         rsurface.modelnum_triangles = numtriangles;
7375         if (rsurface.array_size < rsurface.modelnum_vertices)
7376                 R_Mesh_ResizeArrays(rsurface.modelnum_vertices);
7377         rsurface.matrix = *matrix;
7378         rsurface.inversematrix = *inversematrix;
7379         rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
7380         rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
7381         R_EntityMatrix(&rsurface.matrix);
7382         Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
7383         Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
7384         rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
7385         rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
7386         rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
7387         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
7388         VectorSet(rsurface.modellight_ambient, 0, 0, 0);
7389         VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
7390         VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
7391         VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
7392         VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
7393         Vector4Set(rsurface.colormod, r * r_refdef.view.colorscale, g * r_refdef.view.colorscale, b * r_refdef.view.colorscale, a);
7394         VectorSet(rsurface.glowmod, r_refdef.view.colorscale * r_hdr_glowintensity.value, r_refdef.view.colorscale * r_hdr_glowintensity.value, r_refdef.view.colorscale * r_hdr_glowintensity.value);
7395         memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
7396         rsurface.frameblend[0].lerp = 1;
7397         rsurface.ent_alttextures = false;
7398         rsurface.basepolygonfactor = r_refdef.polygonfactor;
7399         rsurface.basepolygonoffset = r_refdef.polygonoffset;
7400         if (wanttangents)
7401         {
7402                 rsurface.modelvertex3f = vertex3f;
7403                 rsurface.modelsvector3f = svector3f ? svector3f : rsurface.array_modelsvector3f;
7404                 rsurface.modeltvector3f = tvector3f ? tvector3f : rsurface.array_modeltvector3f;
7405                 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
7406         }
7407         else if (wantnormals)
7408         {
7409                 rsurface.modelvertex3f = vertex3f;
7410                 rsurface.modelsvector3f = NULL;
7411                 rsurface.modeltvector3f = NULL;
7412                 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
7413         }
7414         else
7415         {
7416                 rsurface.modelvertex3f = vertex3f;
7417                 rsurface.modelsvector3f = NULL;
7418                 rsurface.modeltvector3f = NULL;
7419                 rsurface.modelnormal3f = NULL;
7420         }
7421         rsurface.modelvertex3f_bufferobject = 0;
7422         rsurface.modelvertex3f_bufferoffset = 0;
7423         rsurface.modelsvector3f_bufferobject = 0;
7424         rsurface.modelsvector3f_bufferoffset = 0;
7425         rsurface.modeltvector3f_bufferobject = 0;
7426         rsurface.modeltvector3f_bufferoffset = 0;
7427         rsurface.modelnormal3f_bufferobject = 0;
7428         rsurface.modelnormal3f_bufferoffset = 0;
7429         rsurface.generatedvertex = true;
7430         rsurface.modellightmapcolor4f  = color4f;
7431         rsurface.modellightmapcolor4f_bufferobject = 0;
7432         rsurface.modellightmapcolor4f_bufferoffset = 0;
7433         rsurface.modeltexcoordtexture2f  = texcoord2f;
7434         rsurface.modeltexcoordtexture2f_bufferobject = 0;
7435         rsurface.modeltexcoordtexture2f_bufferoffset = 0;
7436         rsurface.modeltexcoordlightmap2f  = NULL;
7437         rsurface.modeltexcoordlightmap2f_bufferobject = 0;
7438         rsurface.modeltexcoordlightmap2f_bufferoffset = 0;
7439         rsurface.modelelement3i = element3i;
7440         rsurface.modelelement3s = element3s;
7441         rsurface.modelelement3i_bufferobject = 0;
7442         rsurface.modelelement3s_bufferobject = 0;
7443         rsurface.modellightmapoffsets = NULL;
7444         rsurface.modelsurfaces = NULL;
7445         rsurface.vertex3f  = rsurface.modelvertex3f;
7446         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
7447         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
7448         rsurface.svector3f = rsurface.modelsvector3f;
7449         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
7450         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
7451         rsurface.tvector3f = rsurface.modeltvector3f;
7452         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
7453         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
7454         rsurface.normal3f  = rsurface.modelnormal3f;
7455         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
7456         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
7457         rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
7458
7459         if (rsurface.modelnum_vertices && rsurface.modelelement3i)
7460         {
7461                 if ((wantnormals || wanttangents) && !normal3f)
7462                         Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
7463                 if (wanttangents && !svector3f)
7464                         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 != 0);
7465         }
7466 }
7467
7468 float RSurf_FogPoint(const float *v)
7469 {
7470         // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
7471         float FogPlaneViewDist = r_refdef.fogplaneviewdist;
7472         float FogPlaneVertexDist = DotProduct(r_refdef.fogplane, v) + r_refdef.fogplane[3];
7473         float FogHeightFade = r_refdef.fogheightfade;
7474         float fogfrac;
7475         unsigned int fogmasktableindex;
7476         if (r_refdef.fogplaneviewabove)
7477                 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
7478         else
7479                 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
7480         fogmasktableindex = (unsigned int)(VectorDistance(r_refdef.view.origin, v) * fogfrac * r_refdef.fogmasktabledistmultiplier);
7481         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
7482 }
7483
7484 float RSurf_FogVertex(const float *v)
7485 {
7486         // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
7487         float FogPlaneViewDist = rsurface.fogplaneviewdist;
7488         float FogPlaneVertexDist = DotProduct(rsurface.fogplane, v) + rsurface.fogplane[3];
7489         float FogHeightFade = rsurface.fogheightfade;
7490         float fogfrac;
7491         unsigned int fogmasktableindex;
7492         if (r_refdef.fogplaneviewabove)
7493                 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
7494         else
7495                 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
7496         fogmasktableindex = (unsigned int)(VectorDistance(rsurface.localvieworigin, v) * fogfrac * rsurface.fogmasktabledistmultiplier);
7497         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
7498 }
7499
7500 static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
7501 void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, const msurface_t **texturesurfacelist)
7502 {
7503         int deformindex;
7504         int texturesurfaceindex;
7505         int i, j;
7506         float amplitude;
7507         float animpos;
7508         float scale;
7509         const float *v1, *in_tc;
7510         float *out_tc;
7511         float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
7512         float waveparms[4];
7513         q3shaderinfo_deform_t *deform;
7514         // 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
7515         if (rsurface.generatedvertex)
7516         {
7517                 if (rsurface.texture->tcgen.tcgen == Q3TCGEN_ENVIRONMENT)
7518                         generatenormals = true;
7519                 for (i = 0;i < Q3MAXDEFORMS;i++)
7520                 {
7521                         if (rsurface.texture->deforms[i].deform == Q3DEFORM_AUTOSPRITE)
7522                         {
7523                                 generatetangents = true;
7524                                 generatenormals = true;
7525                         }
7526                         if (rsurface.texture->deforms[i].deform != Q3DEFORM_NONE)
7527                                 generatenormals = true;
7528                 }
7529                 if (generatenormals && !rsurface.modelnormal3f)
7530                 {
7531                         rsurface.normal3f = rsurface.modelnormal3f = rsurface.array_modelnormal3f;
7532                         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject = 0;
7533                         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset = 0;
7534                         Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
7535                 }
7536                 if (generatetangents && !rsurface.modelsvector3f)
7537                 {
7538                         rsurface.svector3f = rsurface.modelsvector3f = rsurface.array_modelsvector3f;
7539                         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject = 0;
7540                         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset = 0;
7541                         rsurface.tvector3f = rsurface.modeltvector3f = rsurface.array_modeltvector3f;
7542                         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject = 0;
7543                         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset = 0;
7544                         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 != 0);
7545                 }
7546         }
7547         rsurface.vertex3f  = rsurface.modelvertex3f;
7548         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
7549         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
7550         rsurface.svector3f = rsurface.modelsvector3f;
7551         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
7552         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
7553         rsurface.tvector3f = rsurface.modeltvector3f;
7554         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
7555         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
7556         rsurface.normal3f  = rsurface.modelnormal3f;
7557         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
7558         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
7559         // if vertices are deformed (sprite flares and things in maps, possibly
7560         // water waves, bulges and other deformations), generate them into
7561         // rsurface.deform* arrays from whatever the rsurface.* arrays point to
7562         // (may be static model data or generated data for an animated model, or
7563         //  the previous deform pass)
7564         for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
7565         {
7566                 switch (deform->deform)
7567                 {
7568                 default:
7569                 case Q3DEFORM_PROJECTIONSHADOW:
7570                 case Q3DEFORM_TEXT0:
7571                 case Q3DEFORM_TEXT1:
7572                 case Q3DEFORM_TEXT2:
7573                 case Q3DEFORM_TEXT3:
7574                 case Q3DEFORM_TEXT4:
7575                 case Q3DEFORM_TEXT5:
7576                 case Q3DEFORM_TEXT6:
7577                 case Q3DEFORM_TEXT7:
7578                 case Q3DEFORM_NONE:
7579                         break;
7580                 case Q3DEFORM_AUTOSPRITE:
7581                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
7582                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
7583                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
7584                         VectorNormalize(newforward);
7585                         VectorNormalize(newright);
7586                         VectorNormalize(newup);
7587                         // make deformed versions of only the model vertices used by the specified surfaces
7588                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7589                         {
7590                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7591                                 // a single autosprite surface can contain multiple sprites...
7592                                 for (j = 0;j < surface->num_vertices - 3;j += 4)
7593                                 {
7594                                         VectorClear(center);
7595                                         for (i = 0;i < 4;i++)
7596                                                 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
7597                                         VectorScale(center, 0.25f, center);
7598                                         VectorCopy((rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, forward);
7599                                         VectorCopy((rsurface.svector3f + 3 * surface->num_firstvertex) + j*3, right);
7600                                         VectorCopy((rsurface.tvector3f + 3 * surface->num_firstvertex) + j*3, up);
7601                                         for (i = 0;i < 4;i++)
7602                                         {
7603                                                 VectorSubtract((rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, center, v);
7604                                                 VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
7605                                         }
7606                                 }
7607                                 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 != 0);
7608                                 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 != 0);
7609                         }
7610                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
7611                         rsurface.vertex3f_bufferobject = 0;
7612                         rsurface.vertex3f_bufferoffset = 0;
7613                         rsurface.svector3f = rsurface.array_deformedsvector3f;
7614                         rsurface.svector3f_bufferobject = 0;
7615                         rsurface.svector3f_bufferoffset = 0;
7616                         rsurface.tvector3f = rsurface.array_deformedtvector3f;
7617                         rsurface.tvector3f_bufferobject = 0;
7618                         rsurface.tvector3f_bufferoffset = 0;
7619                         rsurface.normal3f = rsurface.array_deformednormal3f;
7620                         rsurface.normal3f_bufferobject = 0;
7621                         rsurface.normal3f_bufferoffset = 0;
7622                         break;
7623                 case Q3DEFORM_AUTOSPRITE2:
7624                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
7625                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
7626                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
7627                         VectorNormalize(newforward);
7628                         VectorNormalize(newright);
7629                         VectorNormalize(newup);
7630                         // make deformed versions of only the model vertices used by the specified surfaces
7631                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7632                         {
7633                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7634                                 const float *v1, *v2;
7635                                 vec3_t start, end;
7636                                 float f, l;
7637                                 struct
7638                                 {
7639                                         float length2;
7640                                         const float *v1;
7641                                         const float *v2;
7642                                 }
7643                                 shortest[2];
7644                                 memset(shortest, 0, sizeof(shortest));
7645                                 // a single autosprite surface can contain multiple sprites...
7646                                 for (j = 0;j < surface->num_vertices - 3;j += 4)
7647                                 {
7648                                         VectorClear(center);
7649                                         for (i = 0;i < 4;i++)
7650                                                 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
7651                                         VectorScale(center, 0.25f, center);
7652                                         // find the two shortest edges, then use them to define the
7653                                         // axis vectors for rotating around the central axis
7654                                         for (i = 0;i < 6;i++)
7655                                         {
7656                                                 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][0]);
7657                                                 v2 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][1]);
7658 #if 0
7659                                                 Debug_PolygonBegin(NULL, 0);
7660                                                 Debug_PolygonVertex(v1[0], v1[1], v1[2], 0, 0, 1, 0, 0, 1);
7661                                                 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);
7662                                                 Debug_PolygonVertex(v2[0], v2[1], v2[2], 0, 0, 1, 0, 0, 1);
7663                                                 Debug_PolygonEnd();
7664 #endif
7665                                                 l = VectorDistance2(v1, v2);
7666                                                 // this length bias tries to make sense of square polygons, assuming they are meant to be upright
7667                                                 if (v1[2] != v2[2])
7668                                                         l += (1.0f / 1024.0f);
7669                                                 if (shortest[0].length2 > l || i == 0)
7670                                                 {
7671                                                         shortest[1] = shortest[0];
7672                                                         shortest[0].length2 = l;
7673                                                         shortest[0].v1 = v1;
7674                                                         shortest[0].v2 = v2;
7675                                                 }
7676                                                 else if (shortest[1].length2 > l || i == 1)
7677                                                 {
7678                                                         shortest[1].length2 = l;
7679                                                         shortest[1].v1 = v1;
7680                                                         shortest[1].v2 = v2;
7681                                                 }
7682                                         }
7683                                         VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
7684                                         VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
7685 #if 0
7686                                         Debug_PolygonBegin(NULL, 0);
7687                                         Debug_PolygonVertex(start[0], start[1], start[2], 0, 0, 1, 1, 0, 1);
7688                                         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);
7689                                         Debug_PolygonVertex(end[0], end[1], end[2], 0, 0, 0, 1, 1, 1);
7690                                         Debug_PolygonEnd();
7691 #endif
7692                                         // this calculates the right vector from the shortest edge
7693                                         // and the up vector from the edge midpoints
7694                                         VectorSubtract(shortest[0].v1, shortest[0].v2, right);
7695                                         VectorNormalize(right);
7696                                         VectorSubtract(end, start, up);
7697                                         VectorNormalize(up);
7698                                         // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
7699                                         VectorSubtract(rsurface.localvieworigin, center, forward);
7700                                         //Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, forward);
7701                                         VectorNegate(forward, forward);
7702                                         VectorReflect(forward, 0, up, forward);
7703                                         VectorNormalize(forward);
7704                                         CrossProduct(up, forward, newright);
7705                                         VectorNormalize(newright);
7706 #if 0
7707                                         Debug_PolygonBegin(NULL, 0);
7708                                         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);
7709                                         Debug_PolygonVertex(center[0] + right[0] * 8, center[1] + right[1] * 8, center[2] + right[2] * 8, 0, 0, 0, 1, 0, 1);
7710                                         Debug_PolygonVertex(center[0] + up   [0] * 8, center[1] + up   [1] * 8, center[2] + up   [2] * 8, 0, 0, 0, 0, 1, 1);
7711                                         Debug_PolygonEnd();
7712 #endif
7713 #if 0
7714                                         Debug_PolygonBegin(NULL, 0);
7715                                         Debug_PolygonVertex(center[0] + forward [0] * 8, center[1] + forward [1] * 8, center[2] + forward [2] * 8, 0, 0, 1, 0, 0, 1);
7716                                         Debug_PolygonVertex(center[0] + newright[0] * 8, center[1] + newright[1] * 8, center[2] + newright[2] * 8, 0, 0, 0, 1, 0, 1);
7717                                         Debug_PolygonVertex(center[0] + up      [0] * 8, center[1] + up      [1] * 8, center[2] + up      [2] * 8, 0, 0, 0, 0, 1, 1);
7718                                         Debug_PolygonEnd();
7719 #endif
7720                                         // rotate the quad around the up axis vector, this is made
7721                                         // especially easy by the fact we know the quad is flat,
7722                                         // so we only have to subtract the center position and
7723                                         // measure distance along the right vector, and then
7724                                         // multiply that by the newright vector and add back the
7725                                         // center position
7726                                         // we also need to subtract the old position to undo the
7727                                         // displacement from the center, which we do with a
7728                                         // DotProduct, the subtraction/addition of center is also
7729                                         // optimized into DotProducts here
7730                                         l = DotProduct(right, center);
7731                                         for (i = 0;i < 4;i++)
7732                                         {
7733                                                 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + j + i);
7734                                                 f = DotProduct(right, v1) - l;
7735                                                 VectorMAMAM(1, v1, -f, right, f, newright, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
7736                                         }
7737                                 }
7738                                 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 != 0);
7739                                 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 != 0);
7740                         }
7741                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
7742                         rsurface.vertex3f_bufferobject = 0;
7743                         rsurface.vertex3f_bufferoffset = 0;
7744                         rsurface.svector3f = rsurface.array_deformedsvector3f;
7745                         rsurface.svector3f_bufferobject = 0;
7746                         rsurface.svector3f_bufferoffset = 0;
7747                         rsurface.tvector3f = rsurface.array_deformedtvector3f;
7748                         rsurface.tvector3f_bufferobject = 0;
7749                         rsurface.tvector3f_bufferoffset = 0;
7750                         rsurface.normal3f = rsurface.array_deformednormal3f;
7751                         rsurface.normal3f_bufferobject = 0;
7752                         rsurface.normal3f_bufferoffset = 0;
7753                         break;
7754                 case Q3DEFORM_NORMAL:
7755                         // deform the normals to make reflections wavey
7756                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7757                         {
7758                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7759                                 for (j = 0;j < surface->num_vertices;j++)
7760                                 {
7761                                         float vertex[3];
7762                                         float *normal = (rsurface.array_deformednormal3f  + 3 * surface->num_firstvertex) + j*3;
7763                                         VectorScale((rsurface.vertex3f  + 3 * surface->num_firstvertex) + j*3, 0.98f, vertex);
7764                                         VectorCopy((rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, normal);
7765                                         normal[0] += deform->parms[0] * noise4f(      vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
7766                                         normal[1] += deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
7767                                         normal[2] += deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
7768                                         VectorNormalize(normal);
7769                                 }
7770                                 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 != 0);
7771                         }
7772                         rsurface.svector3f = rsurface.array_deformedsvector3f;
7773                         rsurface.svector3f_bufferobject = 0;
7774                         rsurface.svector3f_bufferoffset = 0;
7775                         rsurface.tvector3f = rsurface.array_deformedtvector3f;
7776                         rsurface.tvector3f_bufferobject = 0;
7777                         rsurface.tvector3f_bufferoffset = 0;
7778                         rsurface.normal3f = rsurface.array_deformednormal3f;
7779                         rsurface.normal3f_bufferobject = 0;
7780                         rsurface.normal3f_bufferoffset = 0;
7781                         break;
7782                 case Q3DEFORM_WAVE:
7783                         // deform vertex array to make wavey water and flags and such
7784                         waveparms[0] = deform->waveparms[0];
7785                         waveparms[1] = deform->waveparms[1];
7786                         waveparms[2] = deform->waveparms[2];
7787                         waveparms[3] = deform->waveparms[3];
7788                         // this is how a divisor of vertex influence on deformation
7789                         animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
7790                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
7791                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7792                         {
7793                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7794                                 for (j = 0;j < surface->num_vertices;j++)
7795                                 {
7796                                         float *vertex = (rsurface.array_deformedvertex3f  + 3 * surface->num_firstvertex) + j*3;
7797                                         VectorCopy((rsurface.vertex3f  + 3 * surface->num_firstvertex) + j*3, vertex);
7798                                         // if the wavefunc depends on time, evaluate it per-vertex
7799                                         if (waveparms[3])
7800                                         {
7801                                                 waveparms[2] = deform->waveparms[2] + (vertex[0] + vertex[1] + vertex[2]) * animpos;
7802                                                 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
7803                                         }
7804                                         VectorMA(vertex, scale, (rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, vertex);
7805                                 }
7806                         }
7807                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
7808                         rsurface.vertex3f_bufferobject = 0;
7809                         rsurface.vertex3f_bufferoffset = 0;
7810                         break;
7811                 case Q3DEFORM_BULGE:
7812                         // deform vertex array to make the surface have moving bulges
7813                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7814                         {
7815                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7816                                 for (j = 0;j < surface->num_vertices;j++)
7817                                 {
7818                                         scale = sin((rsurface.modeltexcoordtexture2f[2 * (surface->num_firstvertex + j)] * deform->parms[0] + r_refdef.scene.time * deform->parms[2])) * deform->parms[1];
7819                                         VectorMA(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), scale, rsurface.normal3f + 3 * (surface->num_firstvertex + j), rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
7820                                 }
7821                         }
7822                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
7823                         rsurface.vertex3f_bufferobject = 0;
7824                         rsurface.vertex3f_bufferoffset = 0;
7825                         break;
7826                 case Q3DEFORM_MOVE:
7827                         // deform vertex array
7828                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
7829                         VectorScale(deform->parms, scale, waveparms);
7830                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7831                         {
7832                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7833                                 for (j = 0;j < surface->num_vertices;j++)
7834                                         VectorAdd(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), waveparms, rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
7835                         }
7836                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
7837                         rsurface.vertex3f_bufferobject = 0;
7838                         rsurface.vertex3f_bufferoffset = 0;
7839                         break;
7840                 }
7841         }
7842         // generate texcoords based on the chosen texcoord source
7843         switch(rsurface.texture->tcgen.tcgen)
7844         {
7845         default:
7846         case Q3TCGEN_TEXTURE:
7847                 rsurface.texcoordtexture2f               = rsurface.modeltexcoordtexture2f;
7848                 rsurface.texcoordtexture2f_bufferobject  = rsurface.modeltexcoordtexture2f_bufferobject;
7849                 rsurface.texcoordtexture2f_bufferoffset  = rsurface.modeltexcoordtexture2f_bufferoffset;
7850                 break;
7851         case Q3TCGEN_LIGHTMAP:
7852                 rsurface.texcoordtexture2f               = rsurface.modeltexcoordlightmap2f;
7853                 rsurface.texcoordtexture2f_bufferobject  = rsurface.modeltexcoordlightmap2f_bufferobject;
7854                 rsurface.texcoordtexture2f_bufferoffset  = rsurface.modeltexcoordlightmap2f_bufferoffset;
7855                 break;
7856         case Q3TCGEN_VECTOR:
7857                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7858                 {
7859                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7860                         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)
7861                         {
7862                                 out_tc[0] = DotProduct(v1, rsurface.texture->tcgen.parms);
7863                                 out_tc[1] = DotProduct(v1, rsurface.texture->tcgen.parms + 3);
7864                         }
7865                 }
7866                 rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
7867                 rsurface.texcoordtexture2f_bufferobject  = 0;
7868                 rsurface.texcoordtexture2f_bufferoffset  = 0;
7869                 break;
7870         case Q3TCGEN_ENVIRONMENT:
7871                 // make environment reflections using a spheremap
7872                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7873                 {
7874                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7875                         const float *vertex = rsurface.modelvertex3f + 3 * surface->num_firstvertex;
7876                         const float *normal = rsurface.modelnormal3f + 3 * surface->num_firstvertex;
7877                         float *out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;
7878                         for (j = 0;j < surface->num_vertices;j++, vertex += 3, normal += 3, out_tc += 2)
7879                         {
7880                                 // identical to Q3A's method, but executed in worldspace so
7881                                 // carried models can be shiny too
7882
7883                                 float viewer[3], d, reflected[3], worldreflected[3];
7884
7885                                 VectorSubtract(rsurface.localvieworigin, vertex, viewer);
7886                                 // VectorNormalize(viewer);
7887
7888                                 d = DotProduct(normal, viewer);
7889
7890                                 reflected[0] = normal[0]*2*d - viewer[0];
7891                                 reflected[1] = normal[1]*2*d - viewer[1];
7892                                 reflected[2] = normal[2]*2*d - viewer[2];
7893                                 // note: this is proportinal to viewer, so we can normalize later
7894
7895                                 Matrix4x4_Transform3x3(&rsurface.matrix, reflected, worldreflected);
7896                                 VectorNormalize(worldreflected);
7897
7898                                 // note: this sphere map only uses world x and z!
7899                                 // so positive and negative y will LOOK THE SAME.
7900                                 out_tc[0] = 0.5 + 0.5 * worldreflected[1];
7901                                 out_tc[1] = 0.5 - 0.5 * worldreflected[2];
7902                         }
7903                 }
7904                 rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
7905                 rsurface.texcoordtexture2f_bufferobject  = 0;
7906                 rsurface.texcoordtexture2f_bufferoffset  = 0;
7907                 break;
7908         }
7909         // the only tcmod that needs software vertex processing is turbulent, so
7910         // check for it here and apply the changes if needed
7911         // and we only support that as the first one
7912         // (handling a mixture of turbulent and other tcmods would be problematic
7913         //  without punting it entirely to a software path)
7914         if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
7915         {
7916                 amplitude = rsurface.texture->tcmods[0].parms[1];
7917                 animpos = rsurface.texture->tcmods[0].parms[2] + r_refdef.scene.time * rsurface.texture->tcmods[0].parms[3];
7918                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7919                 {
7920                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7921                         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)
7922                         {
7923                                 out_tc[0] = in_tc[0] + amplitude * sin(((v1[0] + v1[2]) * 1.0 / 1024.0f + animpos) * M_PI * 2);
7924                                 out_tc[1] = in_tc[1] + amplitude * sin(((v1[1]        ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
7925                         }
7926                 }
7927                 rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
7928                 rsurface.texcoordtexture2f_bufferobject  = 0;
7929                 rsurface.texcoordtexture2f_bufferoffset  = 0;
7930         }
7931         rsurface.texcoordlightmap2f              = rsurface.modeltexcoordlightmap2f;
7932         rsurface.texcoordlightmap2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
7933         rsurface.texcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
7934         R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
7935 }
7936
7937 void RSurf_DrawBatch_Simple(int texturenumsurfaces, const msurface_t **texturesurfacelist)
7938 {
7939         int i, j;
7940         const msurface_t *surface = texturesurfacelist[0];
7941         const msurface_t *surface2;
7942         int firstvertex;
7943         int endvertex;
7944         int numvertices;
7945         int numtriangles;
7946         // TODO: lock all array ranges before render, rather than on each surface
7947         if (texturenumsurfaces == 1)
7948         {
7949                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
7950                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
7951         }
7952         else if (r_batchmode.integer == 2)
7953         {
7954                 #define MAXBATCHTRIANGLES 4096
7955                 int batchtriangles = 0;
7956                 static int batchelements[MAXBATCHTRIANGLES*3];
7957                 for (i = 0;i < texturenumsurfaces;i = j)
7958                 {
7959                         surface = texturesurfacelist[i];
7960                         j = i + 1;
7961                         if (surface->num_triangles > MAXBATCHTRIANGLES)
7962                         {
7963                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
7964                                 continue;
7965                         }
7966                         memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
7967                         batchtriangles = surface->num_triangles;
7968                         firstvertex = surface->num_firstvertex;
7969                         endvertex = surface->num_firstvertex + surface->num_vertices;
7970                         for (;j < texturenumsurfaces;j++)
7971                         {
7972                                 surface2 = texturesurfacelist[j];
7973                                 if (batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
7974                                         break;
7975                                 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
7976                                 batchtriangles += surface2->num_triangles;
7977                                 firstvertex = min(firstvertex, surface2->num_firstvertex);
7978                                 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
7979                         }
7980                         surface2 = texturesurfacelist[j-1];
7981                         numvertices = endvertex - firstvertex;
7982                         R_Mesh_Draw(firstvertex, numvertices, 0, batchtriangles, batchelements, NULL, 0, 0);
7983                 }
7984         }
7985         else if (r_batchmode.integer == 1)
7986         {
7987                 for (i = 0;i < texturenumsurfaces;i = j)
7988                 {
7989                         surface = texturesurfacelist[i];
7990                         for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
7991                                 if (texturesurfacelist[j] != surface2)
7992                                         break;
7993                         surface2 = texturesurfacelist[j-1];
7994                         numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
7995                         numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
7996                         GL_LockArrays(surface->num_firstvertex, numvertices);
7997                         R_Mesh_Draw(surface->num_firstvertex, numvertices, surface->num_firsttriangle, numtriangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
7998                 }
7999         }
8000         else
8001         {
8002                 for (i = 0;i < texturenumsurfaces;i++)
8003                 {
8004                         surface = texturesurfacelist[i];
8005                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8006                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8007                 }
8008         }
8009 }
8010
8011 static void RSurf_BindLightmapForSurface(const msurface_t *surface)
8012 {
8013         switch(vid.renderpath)
8014         {
8015         case RENDERPATH_CGGL:
8016 #ifdef SUPPORTCG
8017                 if (r_cg_permutation->fp_Texture_Lightmap ) CG_BindTexture(r_cg_permutation->fp_Texture_Lightmap , R_GetTexture(surface->lightmaptexture ));CHECKCGERROR
8018                 if (r_cg_permutation->fp_Texture_Deluxemap) CG_BindTexture(r_cg_permutation->fp_Texture_Deluxemap, R_GetTexture(surface->deluxemaptexture));CHECKCGERROR
8019 #endif
8020                 break;
8021         case RENDERPATH_GL20:
8022                 if (r_glsl_permutation->loc_Texture_Lightmap  >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP , R_GetTexture(surface->lightmaptexture ));
8023                 if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(GL20TU_DELUXEMAP, R_GetTexture(surface->deluxemaptexture));
8024                 break;
8025         case RENDERPATH_GL13:
8026         case RENDERPATH_GL11:
8027                 R_Mesh_TexBind(0, R_GetTexture(surface->lightmaptexture));
8028                 break;
8029         }
8030 }
8031
8032 static void RSurf_BindReflectionForSurface(const msurface_t *surface)
8033 {
8034         // pick the closest matching water plane and bind textures
8035         int planeindex, vertexindex;
8036         float d, bestd;
8037         vec3_t vert;
8038         const float *v;
8039         r_waterstate_waterplane_t *p, *bestp;
8040         bestd = 0;
8041         bestp = NULL;
8042         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
8043         {
8044                 d = 0;
8045                 for (vertexindex = 0, v = rsurface.modelvertex3f + surface->num_firstvertex * 3;vertexindex < surface->num_vertices;vertexindex++, v += 3)
8046                 {
8047                         Matrix4x4_Transform(&rsurface.matrix, v, vert);
8048                         d += fabs(PlaneDiff(vert, &p->plane));
8049                 }
8050                 if (bestd > d || !bestp)
8051                 {
8052                         bestd = d;
8053                         bestp = p;
8054                 }
8055         }
8056         switch(vid.renderpath)
8057         {
8058         case RENDERPATH_CGGL:
8059 #ifdef SUPPORTCG
8060                 if (r_cg_permutation->fp_Texture_Refraction) CG_BindTexture(r_cg_permutation->fp_Texture_Refraction, bestp ? R_GetTexture(bestp->texture_refraction) : R_GetTexture(r_texture_black));CHECKCGERROR
8061                 if (r_cg_permutation->fp_Texture_Reflection) CG_BindTexture(r_cg_permutation->fp_Texture_Reflection, bestp ? R_GetTexture(bestp->texture_reflection) : R_GetTexture(r_texture_black));CHECKCGERROR
8062 #endif
8063                 break;
8064         case RENDERPATH_GL20:
8065                 if (r_glsl_permutation->loc_Texture_Refraction >= 0) R_Mesh_TexBind(GL20TU_REFRACTION, bestp ? R_GetTexture(bestp->texture_refraction) : R_GetTexture(r_texture_black));
8066                 if (r_glsl_permutation->loc_Texture_Reflection >= 0) R_Mesh_TexBind(GL20TU_REFLECTION, bestp ? R_GetTexture(bestp->texture_reflection) : R_GetTexture(r_texture_black));
8067                 break;
8068         case RENDERPATH_GL13:
8069         case RENDERPATH_GL11:
8070                 break;
8071         }
8072 }
8073
8074 static void RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8075 {
8076         int i;
8077         const msurface_t *surface;
8078         if (r_waterstate.renderingscene)
8079                 return;
8080         for (i = 0;i < texturenumsurfaces;i++)
8081         {
8082                 surface = texturesurfacelist[i];
8083                 RSurf_BindLightmapForSurface(surface);
8084                 RSurf_BindReflectionForSurface(surface);
8085                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8086                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8087         }
8088 }
8089
8090 static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8091 {
8092         int i;
8093         int j;
8094         const msurface_t *surface = texturesurfacelist[0];
8095         const msurface_t *surface2;
8096         int firstvertex;
8097         int endvertex;
8098         int numvertices;
8099         int numtriangles;
8100         if (texturenumsurfaces == 1)
8101         {
8102                 RSurf_BindLightmapForSurface(surface);
8103                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8104                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8105         }
8106         else if (r_batchmode.integer == 2)
8107         {
8108 #define MAXBATCHTRIANGLES 4096
8109                 int batchtriangles = 0;
8110                 static int batchelements[MAXBATCHTRIANGLES*3];
8111                 for (i = 0;i < texturenumsurfaces;i = j)
8112                 {
8113                         surface = texturesurfacelist[i];
8114                         RSurf_BindLightmapForSurface(surface);
8115                         j = i + 1;
8116                         if (surface->num_triangles > MAXBATCHTRIANGLES)
8117                         {
8118                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8119                                 continue;
8120                         }
8121                         memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
8122                         batchtriangles = surface->num_triangles;
8123                         firstvertex = surface->num_firstvertex;
8124                         endvertex = surface->num_firstvertex + surface->num_vertices;
8125                         for (;j < texturenumsurfaces;j++)
8126                         {
8127                                 surface2 = texturesurfacelist[j];
8128                                 if (surface2->lightmaptexture != surface->lightmaptexture || batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
8129                                         break;
8130                                 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
8131                                 batchtriangles += surface2->num_triangles;
8132                                 firstvertex = min(firstvertex, surface2->num_firstvertex);
8133                                 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
8134                         }
8135                         surface2 = texturesurfacelist[j-1];
8136                         numvertices = endvertex - firstvertex;
8137                         R_Mesh_Draw(firstvertex, numvertices, 0, batchtriangles, batchelements, NULL, 0, 0);
8138                 }
8139         }
8140         else if (r_batchmode.integer == 1)
8141         {
8142 #if 0
8143                 Con_Printf("%s batch sizes ignoring lightmap:", rsurface.texture->name);
8144                 for (i = 0;i < texturenumsurfaces;i = j)
8145                 {
8146                         surface = texturesurfacelist[i];
8147                         for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
8148                                 if (texturesurfacelist[j] != surface2)
8149                                         break;
8150                         Con_Printf(" %i", j - i);
8151                 }
8152                 Con_Printf("\n");
8153                 Con_Printf("%s batch sizes honoring lightmap:", rsurface.texture->name);
8154 #endif
8155                 for (i = 0;i < texturenumsurfaces;i = j)
8156                 {
8157                         surface = texturesurfacelist[i];
8158                         RSurf_BindLightmapForSurface(surface);
8159                         for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
8160                                 if (texturesurfacelist[j] != surface2 || texturesurfacelist[j]->lightmaptexture != surface->lightmaptexture)
8161                                         break;
8162 #if 0
8163                         Con_Printf(" %i", j - i);
8164 #endif
8165                         surface2 = texturesurfacelist[j-1];
8166                         numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
8167                         numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
8168                         GL_LockArrays(surface->num_firstvertex, numvertices);
8169                         R_Mesh_Draw(surface->num_firstvertex, numvertices, surface->num_firsttriangle, numtriangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8170                 }
8171 #if 0
8172                 Con_Printf("\n");
8173 #endif
8174         }
8175         else
8176         {
8177                 for (i = 0;i < texturenumsurfaces;i++)
8178                 {
8179                         surface = texturesurfacelist[i];
8180                         RSurf_BindLightmapForSurface(surface);
8181                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8182                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8183                 }
8184         }
8185 }
8186
8187 static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8188 {
8189         int j;
8190         int texturesurfaceindex;
8191         if (r_showsurfaces.integer == 2)
8192         {
8193                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8194                 {
8195                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8196                         for (j = 0;j < surface->num_triangles;j++)
8197                         {
8198                                 float f = ((j + surface->num_firsttriangle) & 31) * (1.0f / 31.0f) * r_refdef.view.colorscale;
8199                                 GL_Color(f, f, f, 1);
8200                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle + j, 1, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8201                         }
8202                 }
8203         }
8204         else
8205         {
8206                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8207                 {
8208                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8209                         int k = (int)(((size_t)surface) / sizeof(msurface_t));
8210                         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);
8211                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8212                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8213                 }
8214         }
8215 }
8216
8217 static void RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8218 {
8219         int texturesurfaceindex;
8220         int i;
8221         const float *v;
8222         float *c2;
8223         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8224         {
8225                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8226                 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)
8227                 {
8228                         c2[0] = 0.5;
8229                         c2[1] = 0.5;
8230                         c2[2] = 0.5;
8231                         c2[3] = 1;
8232                 }
8233         }
8234         rsurface.lightmapcolor4f = rsurface.array_color4f;
8235         rsurface.lightmapcolor4f_bufferobject = 0;
8236         rsurface.lightmapcolor4f_bufferoffset = 0;
8237 }
8238
8239 static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8240 {
8241         int texturesurfaceindex;
8242         int i;
8243         float f;
8244         const float *v;
8245         const float *c;
8246         float *c2;
8247         if (rsurface.lightmapcolor4f)
8248         {
8249                 // generate color arrays for the surfaces in this list
8250                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8251                 {
8252                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8253                         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)
8254                         {
8255                                 f = RSurf_FogVertex(v);
8256                                 c2[0] = c[0] * f;
8257                                 c2[1] = c[1] * f;
8258                                 c2[2] = c[2] * f;
8259                                 c2[3] = c[3];
8260                         }
8261                 }
8262         }
8263         else
8264         {
8265                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8266                 {
8267                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8268                         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)
8269                         {
8270                                 f = RSurf_FogVertex(v);
8271                                 c2[0] = f;
8272                                 c2[1] = f;
8273                                 c2[2] = f;
8274                                 c2[3] = 1;
8275                         }
8276                 }
8277         }
8278         rsurface.lightmapcolor4f = rsurface.array_color4f;
8279         rsurface.lightmapcolor4f_bufferobject = 0;
8280         rsurface.lightmapcolor4f_bufferoffset = 0;
8281 }
8282
8283 static void RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8284 {
8285         int texturesurfaceindex;
8286         int i;
8287         float f;
8288         const float *v;
8289         const float *c;
8290         float *c2;
8291         if (!rsurface.lightmapcolor4f)
8292                 return;
8293         // generate color arrays for the surfaces in this list
8294         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8295         {
8296                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8297                 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)
8298                 {
8299                         f = RSurf_FogVertex(v);
8300                         c2[0] = c[0] * f + r_refdef.fogcolor[0] * (1 - f);
8301                         c2[1] = c[1] * f + r_refdef.fogcolor[1] * (1 - f);
8302                         c2[2] = c[2] * f + r_refdef.fogcolor[2] * (1 - f);
8303                         c2[3] = c[3];
8304                 }
8305         }
8306         rsurface.lightmapcolor4f = rsurface.array_color4f;
8307         rsurface.lightmapcolor4f_bufferobject = 0;
8308         rsurface.lightmapcolor4f_bufferoffset = 0;
8309 }
8310
8311 static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a)
8312 {
8313         int texturesurfaceindex;
8314         int i;
8315         const float *c;
8316         float *c2;
8317         if (!rsurface.lightmapcolor4f)
8318                 return;
8319         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8320         {
8321                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8322                 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)
8323                 {
8324                         c2[0] = c[0] * r;
8325                         c2[1] = c[1] * g;
8326                         c2[2] = c[2] * b;
8327                         c2[3] = c[3] * a;
8328                 }
8329         }
8330         rsurface.lightmapcolor4f = rsurface.array_color4f;
8331         rsurface.lightmapcolor4f_bufferobject = 0;
8332         rsurface.lightmapcolor4f_bufferoffset = 0;
8333 }
8334
8335 static void RSurf_DrawBatch_GL11_ApplyAmbient(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8336 {
8337         int texturesurfaceindex;
8338         int i;
8339         const float *c;
8340         float *c2;
8341         if (!rsurface.lightmapcolor4f)
8342                 return;
8343         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8344         {
8345                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8346                 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)
8347                 {
8348                         c2[0] = c[0] + r_refdef.scene.ambient;
8349                         c2[1] = c[1] + r_refdef.scene.ambient;
8350                         c2[2] = c[2] + r_refdef.scene.ambient;
8351                         c2[3] = c[3];
8352                 }
8353         }
8354         rsurface.lightmapcolor4f = rsurface.array_color4f;
8355         rsurface.lightmapcolor4f_bufferobject = 0;
8356         rsurface.lightmapcolor4f_bufferoffset = 0;
8357 }
8358
8359 static void RSurf_DrawBatch_GL11_Lightmap(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
8360 {
8361         // TODO: optimize
8362         rsurface.lightmapcolor4f = NULL;
8363         rsurface.lightmapcolor4f_bufferobject = 0;
8364         rsurface.lightmapcolor4f_bufferoffset = 0;
8365         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
8366         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
8367         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
8368         GL_Color(r, g, b, a);
8369         RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist);
8370 }
8371
8372 static void RSurf_DrawBatch_GL11_Unlit(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
8373 {
8374         // TODO: optimize applyfog && applycolor case
8375         // just apply fog if necessary, and tint the fog color array if necessary
8376         rsurface.lightmapcolor4f = NULL;
8377         rsurface.lightmapcolor4f_bufferobject = 0;
8378         rsurface.lightmapcolor4f_bufferoffset = 0;
8379         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
8380         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
8381         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
8382         GL_Color(r, g, b, a);
8383         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8384 }
8385
8386 static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
8387 {
8388         int texturesurfaceindex;
8389         int i;
8390         float *c;
8391         // TODO: optimize
8392         if (texturesurfacelist[0]->lightmapinfo)
8393         {
8394                 // generate color arrays for the surfaces in this list
8395                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8396                 {
8397                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8398                         for (i = 0, c = rsurface.array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
8399                         {
8400                                 if (surface->lightmapinfo->samples)
8401                                 {
8402                                         const unsigned char *lm = surface->lightmapinfo->samples + (rsurface.modellightmapoffsets + surface->num_firstvertex)[i];
8403                                         float scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
8404                                         VectorScale(lm, scale, c);
8405                                         if (surface->lightmapinfo->styles[1] != 255)
8406                                         {
8407                                                 int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
8408                                                 lm += size3;
8409                                                 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
8410                                                 VectorMA(c, scale, lm, c);
8411                                                 if (surface->lightmapinfo->styles[2] != 255)
8412                                                 {
8413                                                         lm += size3;
8414                                                         scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
8415                                                         VectorMA(c, scale, lm, c);
8416                                                         if (surface->lightmapinfo->styles[3] != 255)
8417                                                         {
8418                                                                 lm += size3;
8419                                                                 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
8420                                                                 VectorMA(c, scale, lm, c);
8421                                                         }
8422                                                 }
8423                                         }
8424                                 }
8425                                 else
8426                                         VectorClear(c);
8427                                 c[3] = 1;
8428                         }
8429                 }
8430                 rsurface.lightmapcolor4f = rsurface.array_color4f;
8431                 rsurface.lightmapcolor4f_bufferobject = 0;
8432                 rsurface.lightmapcolor4f_bufferoffset = 0;
8433         }
8434         else
8435         {
8436                 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
8437                 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
8438                 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
8439         }
8440         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
8441         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
8442         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
8443         GL_Color(r, g, b, a);
8444         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8445 }
8446
8447 static void RSurf_DrawBatch_GL11_ApplyVertexShade(int texturenumsurfaces, const msurface_t **texturesurfacelist, float *r, float *g, float *b, float *a, qboolean *applycolor)
8448 {
8449         int texturesurfaceindex;
8450         int i;
8451         float f;
8452         float alpha;
8453         const float *v;
8454         const float *n;
8455         float *c;
8456         vec3_t ambientcolor;
8457         vec3_t diffusecolor;
8458         vec3_t lightdir;
8459         // TODO: optimize
8460         // model lighting
8461         VectorCopy(rsurface.modellight_lightdir, lightdir);
8462         f = 0.5f * r_refdef.lightmapintensity;
8463         ambientcolor[0] = rsurface.modellight_ambient[0] * *r * f;
8464         ambientcolor[1] = rsurface.modellight_ambient[1] * *g * f;
8465         ambientcolor[2] = rsurface.modellight_ambient[2] * *b * f;
8466         diffusecolor[0] = rsurface.modellight_diffuse[0] * *r * f;
8467         diffusecolor[1] = rsurface.modellight_diffuse[1] * *g * f;
8468         diffusecolor[2] = rsurface.modellight_diffuse[2] * *b * f;
8469         alpha = *a;
8470         if (VectorLength2(diffusecolor) > 0 && rsurface.normal3f)
8471         {
8472                 // generate color arrays for the surfaces in this list
8473                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8474                 {
8475                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8476                         int numverts = surface->num_vertices;
8477                         v = rsurface.vertex3f + 3 * surface->num_firstvertex;
8478                         n = rsurface.normal3f + 3 * surface->num_firstvertex;
8479                         c = rsurface.array_color4f + 4 * surface->num_firstvertex;
8480                         // q3-style directional shading
8481                         for (i = 0;i < numverts;i++, v += 3, n += 3, c += 4)
8482                         {
8483                                 if ((f = DotProduct(n, lightdir)) > 0)
8484                                         VectorMA(ambientcolor, f, diffusecolor, c);
8485                                 else
8486                                         VectorCopy(ambientcolor, c);
8487                                 c[3] = alpha;
8488                         }
8489                 }
8490                 *r = 1;
8491                 *g = 1;
8492                 *b = 1;
8493                 *a = 1;
8494                 rsurface.lightmapcolor4f = rsurface.array_color4f;
8495                 rsurface.lightmapcolor4f_bufferobject = 0;
8496                 rsurface.lightmapcolor4f_bufferoffset = 0;
8497                 *applycolor = false;
8498         }
8499         else
8500         {
8501                 *r = ambientcolor[0];
8502                 *g = ambientcolor[1];
8503                 *b = ambientcolor[2];
8504                 rsurface.lightmapcolor4f = NULL;
8505                 rsurface.lightmapcolor4f_bufferobject = 0;
8506                 rsurface.lightmapcolor4f_bufferoffset = 0;
8507         }
8508 }
8509
8510 static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
8511 {
8512         RSurf_DrawBatch_GL11_ApplyVertexShade(texturenumsurfaces, texturesurfacelist, &r, &g, &b, &a, &applycolor);
8513         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
8514         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
8515         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
8516         GL_Color(r, g, b, a);
8517         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8518 }
8519
8520 void RSurf_SetupDepthAndCulling(void)
8521 {
8522         // submodels are biased to avoid z-fighting with world surfaces that they
8523         // may be exactly overlapping (avoids z-fighting artifacts on certain
8524         // doors and things in Quake maps)
8525         GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
8526         GL_PolygonOffset(rsurface.basepolygonfactor + rsurface.texture->biaspolygonfactor, rsurface.basepolygonoffset + rsurface.texture->biaspolygonoffset);
8527         GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
8528         GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_refdef.view.cullface_back);
8529 }
8530
8531 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8532 {
8533         // transparent sky would be ridiculous
8534         if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
8535                 return;
8536         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8537         skyrenderlater = true;
8538         RSurf_SetupDepthAndCulling();
8539         GL_DepthMask(true);
8540         // LordHavoc: HalfLife maps have freaky skypolys so don't use
8541         // skymasking on them, and Quake3 never did sky masking (unlike
8542         // software Quake and software Quake2), so disable the sky masking
8543         // in Quake3 maps as it causes problems with q3map2 sky tricks,
8544         // and skymasking also looks very bad when noclipping outside the
8545         // level, so don't use it then either.
8546         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_refdef.viewcache.world_novis)
8547         {
8548                 GL_Color(r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], 1);
8549                 R_Mesh_ColorPointer(NULL, 0, 0);
8550                 R_Mesh_ResetTextureState();
8551                 if (skyrendermasked)
8552                 {
8553                         R_SetupShader_DepthOrShadow();
8554                         // depth-only (masking)
8555                         GL_ColorMask(0,0,0,0);
8556                         // just to make sure that braindead drivers don't draw
8557                         // anything despite that colormask...
8558                         GL_BlendFunc(GL_ZERO, GL_ONE);
8559                 }
8560                 else
8561                 {
8562                         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8563                         // fog sky
8564                         GL_BlendFunc(GL_ONE, GL_ZERO);
8565                 }
8566                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
8567                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8568                 if (skyrendermasked)
8569                         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
8570         }
8571         R_Mesh_ResetTextureState();
8572         GL_Color(1, 1, 1, 1);
8573 }
8574
8575 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
8576 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
8577 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
8578 {
8579         qboolean reflect = (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)) && !prepass;
8580         qboolean refract = (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION)) && !prepass;
8581
8582         if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION)))
8583                 return;
8584
8585         if ((rsurface.uselightmaptexture || (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND))
8586                 R_Mesh_ColorPointer(NULL, 0, 0);
8587         else
8588                 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
8589
8590         if (refract)
8591         {
8592                 // render background
8593                 GL_BlendFunc(GL_ONE, GL_ZERO);
8594                 GL_DepthMask(true);
8595                 GL_AlphaTest(false);
8596
8597                 GL_Color(1, 1, 1, 1);
8598                 R_Mesh_ColorPointer(NULL, 0, 0);
8599
8600                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND);
8601                 RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
8602                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8603                 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
8604                 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
8605                 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
8606                 R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
8607                 RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist);
8608                 GL_LockArrays(0, 0);
8609
8610                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
8611                 GL_DepthMask(false);
8612                 if ((rsurface.uselightmaptexture || (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND))
8613                         R_Mesh_ColorPointer(NULL, 0, 0);
8614                 else
8615                         R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
8616         }
8617
8618         R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, prepass ? RSURFPASS_DEFERREDGEOMETRY : RSURFPASS_BASE);
8619
8620         RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
8621         R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8622         R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
8623         R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
8624         R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
8625         if (!prepass)
8626                 R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
8627
8628         if (refract)
8629         {
8630                 GL_BlendFunc(GL_ONE, GL_ZERO);
8631                 GL_DepthMask(true);
8632                 GL_AlphaTest(false);
8633         }
8634         else
8635         {
8636                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
8637                 GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
8638                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0 && !r_shadow_usingdeferredprepass);
8639         }
8640
8641         if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
8642         {
8643                 if (refract || reflect)
8644                         RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist);
8645                 else
8646                         RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist);
8647         }
8648         else
8649         {
8650                 if (refract || reflect)
8651                         RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist);
8652                 else
8653                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8654         }
8655         GL_LockArrays(0, 0);
8656 }
8657
8658 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
8659 {
8660         // OpenGL 1.3 path - anything not completely ancient
8661         int texturesurfaceindex;
8662         qboolean applycolor;
8663         qboolean applyfog;
8664         int layerindex;
8665         const texturelayer_t *layer;
8666         RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
8667
8668         for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
8669         {
8670                 vec4_t layercolor;
8671                 int layertexrgbscale;
8672                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8673                 {
8674                         if (layerindex == 0)
8675                                 GL_AlphaTest(true);
8676                         else
8677                         {
8678                                 GL_AlphaTest(false);
8679                                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
8680                         }
8681                 }
8682                 GL_DepthMask(layer->depthmask && writedepth);
8683                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
8684                 if (layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2)
8685                 {
8686                         layertexrgbscale = 4;
8687                         VectorScale(layer->color, 0.25f, layercolor);
8688                 }
8689                 else if (layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1)
8690                 {
8691                         layertexrgbscale = 2;
8692                         VectorScale(layer->color, 0.5f, layercolor);
8693                 }
8694                 else
8695                 {
8696                         layertexrgbscale = 1;
8697                         VectorScale(layer->color, 1.0f, layercolor);
8698                 }
8699                 layercolor[3] = layer->color[3];
8700                 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
8701                 R_Mesh_ColorPointer(NULL, 0, 0);
8702                 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
8703                 switch (layer->type)
8704                 {
8705                 case TEXTURELAYERTYPE_LITTEXTURE:
8706                         // single-pass lightmapped texture with 2x rgbscale
8707                         //R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
8708                         R_Mesh_TexMatrix(0, NULL);
8709                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8710                         R_Mesh_TexCoordPointer(0, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
8711                         R_Mesh_TexBind(1, R_GetTexture(layer->texture));
8712                         R_Mesh_TexMatrix(1, &layer->texmatrix);
8713                         R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
8714                         R_Mesh_TexCoordPointer(1, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8715                         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
8716                                 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
8717                         else if (rsurface.uselightmaptexture)
8718                                 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
8719                         else
8720                                 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
8721                         break;
8722                 case TEXTURELAYERTYPE_TEXTURE:
8723                         // singletexture unlit texture with transparency support
8724                         R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8725                         R_Mesh_TexMatrix(0, &layer->texmatrix);
8726                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
8727                         R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8728                         R_Mesh_TexBind(1, 0);
8729                         R_Mesh_TexCoordPointer(1, 2, NULL, 0, 0);
8730                         RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
8731                         break;
8732                 case TEXTURELAYERTYPE_FOG:
8733                         // singletexture fogging
8734                         if (layer->texture)
8735                         {
8736                                 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8737                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
8738                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
8739                                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8740                         }
8741                         else
8742                         {
8743                                 R_Mesh_TexBind(0, 0);
8744                                 R_Mesh_TexCoordPointer(0, 2, NULL, 0, 0);
8745                         }
8746                         R_Mesh_TexBind(1, 0);
8747                         R_Mesh_TexCoordPointer(1, 2, NULL, 0, 0);
8748                         // generate a color array for the fog pass
8749                         R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
8750                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8751                         {
8752                                 int i;
8753                                 float f;
8754                                 const float *v;
8755                                 float *c;
8756                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8757                                 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)
8758                                 {
8759                                         f = 1 - RSurf_FogVertex(v);
8760                                         c[0] = layercolor[0];
8761                                         c[1] = layercolor[1];
8762                                         c[2] = layercolor[2];
8763                                         c[3] = f * layercolor[3];
8764                                 }
8765                         }
8766                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8767                         break;
8768                 default:
8769                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
8770                 }
8771                 GL_LockArrays(0, 0);
8772         }
8773         CHECKGLERROR
8774         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8775         {
8776                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
8777                 GL_AlphaTest(false);
8778         }
8779 }
8780
8781 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
8782 {
8783         // OpenGL 1.1 - crusty old voodoo path
8784         int texturesurfaceindex;
8785         qboolean applyfog;
8786         int layerindex;
8787         const texturelayer_t *layer;
8788         RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
8789
8790         for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
8791         {
8792                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8793                 {
8794                         if (layerindex == 0)
8795                                 GL_AlphaTest(true);
8796                         else
8797                         {
8798                                 GL_AlphaTest(false);
8799                                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
8800                         }
8801                 }
8802                 GL_DepthMask(layer->depthmask && writedepth);
8803                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
8804                 R_Mesh_ColorPointer(NULL, 0, 0);
8805                 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
8806                 switch (layer->type)
8807                 {
8808                 case TEXTURELAYERTYPE_LITTEXTURE:
8809                         if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
8810                         {
8811                                 // two-pass lit texture with 2x rgbscale
8812                                 // first the lightmap pass
8813                                 //R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
8814                                 R_Mesh_TexMatrix(0, NULL);
8815                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8816                                 R_Mesh_TexCoordPointer(0, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
8817                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
8818                                         RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
8819                                 else if (rsurface.uselightmaptexture)
8820                                         RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
8821                                 else
8822                                         RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
8823                                 GL_LockArrays(0, 0);
8824                                 // then apply the texture to it
8825                                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
8826                                 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8827                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
8828                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8829                                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8830                                 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);
8831                         }
8832                         else
8833                         {
8834                                 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
8835                                 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8836                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
8837                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8838                                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8839                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
8840                                         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);
8841                                 else
8842                                         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);
8843                         }
8844                         break;
8845                 case TEXTURELAYERTYPE_TEXTURE:
8846                         // singletexture unlit texture with transparency support
8847                         R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8848                         R_Mesh_TexMatrix(0, &layer->texmatrix);
8849                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8850                         R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8851                         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);
8852                         break;
8853                 case TEXTURELAYERTYPE_FOG:
8854                         // singletexture fogging
8855                         if (layer->texture)
8856                         {
8857                                 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8858                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
8859                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8860                                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8861                         }
8862                         else
8863                         {
8864                                 R_Mesh_TexBind(0, 0);
8865                                 R_Mesh_TexCoordPointer(0, 2, NULL, 0, 0);
8866                         }
8867                         // generate a color array for the fog pass
8868                         R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
8869                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8870                         {
8871                                 int i;
8872                                 float f;
8873                                 const float *v;
8874                                 float *c;
8875                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8876                                 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)
8877                                 {
8878                                         f = 1 - RSurf_FogVertex(v);
8879                                         c[0] = layer->color[0];
8880                                         c[1] = layer->color[1];
8881                                         c[2] = layer->color[2];
8882                                         c[3] = f * layer->color[3];
8883                                 }
8884                         }
8885                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8886                         break;
8887                 default:
8888                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
8889                 }
8890                 GL_LockArrays(0, 0);
8891         }
8892         CHECKGLERROR
8893         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8894         {
8895                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
8896                 GL_AlphaTest(false);
8897         }
8898 }
8899
8900 static void R_DrawTextureSurfaceList_ShowSurfaces3(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
8901 {
8902         float c[4];
8903
8904         GL_AlphaTest(false);
8905         R_Mesh_ColorPointer(NULL, 0, 0);
8906         R_Mesh_ResetTextureState();
8907         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8908
8909         if(rsurface.texture && rsurface.texture->currentskinframe)
8910         {
8911                 memcpy(c, rsurface.texture->currentskinframe->avgcolor, sizeof(c));
8912                 c[3] *= rsurface.texture->currentalpha;
8913         }
8914         else
8915         {
8916                 c[0] = 1;
8917                 c[1] = 0;
8918                 c[2] = 1;
8919                 c[3] = 1;
8920         }
8921
8922         if (rsurface.texture->pantstexture || rsurface.texture->shirttexture)
8923         {
8924                 c[0] = 0.5 * (rsurface.colormap_pantscolor[0] * 0.3 + rsurface.colormap_shirtcolor[0] * 0.7);
8925                 c[1] = 0.5 * (rsurface.colormap_pantscolor[1] * 0.3 + rsurface.colormap_shirtcolor[1] * 0.7);
8926                 c[2] = 0.5 * (rsurface.colormap_pantscolor[2] * 0.3 + rsurface.colormap_shirtcolor[2] * 0.7);
8927         }
8928
8929         // brighten it up (as texture value 127 means "unlit")
8930         c[0] *= 2 * r_refdef.view.colorscale;
8931         c[1] *= 2 * r_refdef.view.colorscale;
8932         c[2] *= 2 * r_refdef.view.colorscale;
8933
8934         if(rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERALPHA)
8935                 c[3] *= r_wateralpha.value;
8936
8937         if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHA && c[3] != 1)
8938         {
8939                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
8940                 GL_DepthMask(false);
8941         }
8942         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
8943         {
8944                 GL_BlendFunc(GL_ONE, GL_ONE);
8945                 GL_DepthMask(false);
8946         }
8947         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8948         {
8949                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // can't do alpha test without texture, so let's blend instead
8950                 GL_DepthMask(false);
8951         }
8952         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
8953         {
8954                 GL_BlendFunc(rsurface.texture->customblendfunc[0], rsurface.texture->customblendfunc[1]);
8955                 GL_DepthMask(false);
8956         }
8957         else
8958         {
8959                 GL_BlendFunc(GL_ONE, GL_ZERO);
8960                 GL_DepthMask(writedepth);
8961         }
8962
8963         rsurface.lightmapcolor4f = NULL;
8964
8965         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
8966         {
8967                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
8968
8969                 rsurface.lightmapcolor4f = NULL;
8970                 rsurface.lightmapcolor4f_bufferobject = 0;
8971                 rsurface.lightmapcolor4f_bufferoffset = 0;
8972         }
8973         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
8974         {
8975                 qboolean applycolor = true;
8976                 float one = 1.0;
8977
8978                 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
8979
8980                 r_refdef.lightmapintensity = 1;
8981                 RSurf_DrawBatch_GL11_ApplyVertexShade(texturenumsurfaces, texturesurfacelist, &one, &one, &one, &one, &applycolor);
8982                 r_refdef.lightmapintensity = 0; // we're in showsurfaces, after all
8983         }
8984         else
8985         {
8986                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
8987
8988                 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
8989                 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
8990                 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
8991         }
8992
8993         if(!rsurface.lightmapcolor4f)
8994                 RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(texturenumsurfaces, texturesurfacelist);
8995
8996         RSurf_DrawBatch_GL11_ApplyAmbient(texturenumsurfaces, texturesurfacelist);
8997         RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, c[0], c[1], c[2], c[3]);
8998         if(r_refdef.fogenabled)
8999                 RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(texturenumsurfaces, texturesurfacelist);
9000
9001         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
9002         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9003 }
9004
9005 static void R_DrawWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
9006 {
9007         CHECKGLERROR
9008         RSurf_SetupDepthAndCulling();
9009         if (r_showsurfaces.integer == 3 && !prepass)
9010         {
9011                 R_DrawTextureSurfaceList_ShowSurfaces3(texturenumsurfaces, texturesurfacelist, writedepth);
9012                 return;
9013         }
9014         switch (vid.renderpath)
9015         {
9016         case RENDERPATH_GL20:
9017         case RENDERPATH_CGGL:
9018                 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
9019                 break;
9020         case RENDERPATH_GL13:
9021                 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
9022                 break;
9023         case RENDERPATH_GL11:
9024                 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
9025                 break;
9026         }
9027         CHECKGLERROR
9028 }
9029
9030 static void R_DrawModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
9031 {
9032         CHECKGLERROR
9033         RSurf_SetupDepthAndCulling();
9034         if (r_showsurfaces.integer == 3 && !prepass)
9035         {
9036                 R_DrawTextureSurfaceList_ShowSurfaces3(texturenumsurfaces, texturesurfacelist, writedepth);
9037                 return;
9038         }
9039         switch (vid.renderpath)
9040         {
9041         case RENDERPATH_GL20:
9042         case RENDERPATH_CGGL:
9043                 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
9044                 break;
9045         case RENDERPATH_GL13:
9046                 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
9047                 break;
9048         case RENDERPATH_GL11:
9049                 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
9050                 break;
9051         }
9052         CHECKGLERROR
9053 }
9054
9055 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
9056 {
9057         int i, j;
9058         int texturenumsurfaces, endsurface;
9059         texture_t *texture;
9060         const msurface_t *surface;
9061         const msurface_t *texturesurfacelist[256];
9062
9063         // if the model is static it doesn't matter what value we give for
9064         // wantnormals and wanttangents, so this logic uses only rules applicable
9065         // to a model, knowing that they are meaningless otherwise
9066         if (ent == r_refdef.scene.worldentity)
9067                 RSurf_ActiveWorldEntity();
9068         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
9069                 RSurf_ActiveModelEntity(ent, false, false, false);
9070         else
9071         {
9072                 switch (vid.renderpath)
9073                 {
9074                 case RENDERPATH_GL20:
9075                 case RENDERPATH_CGGL:
9076                         RSurf_ActiveModelEntity(ent, true, true, false);
9077                         break;
9078                 case RENDERPATH_GL13:
9079                 case RENDERPATH_GL11:
9080                         RSurf_ActiveModelEntity(ent, true, false, false);
9081                         break;
9082                 }
9083         }
9084
9085         if (r_transparentdepthmasking.integer)
9086         {
9087                 qboolean setup = false;
9088                 for (i = 0;i < numsurfaces;i = j)
9089                 {
9090                         j = i + 1;
9091                         surface = rsurface.modelsurfaces + surfacelist[i];
9092                         texture = surface->texture;
9093                         rsurface.texture = R_GetCurrentTexture(texture);
9094                         rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
9095                         // scan ahead until we find a different texture
9096                         endsurface = min(i + 1024, numsurfaces);
9097                         texturenumsurfaces = 0;
9098                         texturesurfacelist[texturenumsurfaces++] = surface;
9099                         for (;j < endsurface;j++)
9100                         {
9101                                 surface = rsurface.modelsurfaces + surfacelist[j];
9102                                 if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
9103                                         break;
9104                                 texturesurfacelist[texturenumsurfaces++] = surface;
9105                         }
9106                         if (!(rsurface.texture->currentmaterialflags & MATERIALFLAG_TRANSDEPTH))
9107                                 continue;
9108                         // render the range of surfaces as depth
9109                         if (!setup)
9110                         {
9111                                 setup = true;
9112                                 GL_ColorMask(0,0,0,0);
9113                                 GL_Color(1,1,1,1);
9114                                 GL_DepthTest(true);
9115                                 GL_BlendFunc(GL_ONE, GL_ZERO);
9116                                 GL_DepthMask(true);
9117                                 GL_AlphaTest(false);
9118                                 R_Mesh_ColorPointer(NULL, 0, 0);
9119                                 R_Mesh_ResetTextureState();
9120                                 R_SetupShader_DepthOrShadow();
9121                         }
9122                         RSurf_SetupDepthAndCulling();
9123                         RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9124                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9125                 }
9126                 if (setup)
9127                         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
9128         }
9129
9130         for (i = 0;i < numsurfaces;i = j)
9131         {
9132                 j = i + 1;
9133                 surface = rsurface.modelsurfaces + surfacelist[i];
9134                 texture = surface->texture;
9135                 rsurface.texture = R_GetCurrentTexture(texture);
9136                 rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
9137                 // scan ahead until we find a different texture
9138                 endsurface = min(i + 1024, numsurfaces);
9139                 texturenumsurfaces = 0;
9140                 texturesurfacelist[texturenumsurfaces++] = surface;
9141                 for (;j < endsurface;j++)
9142                 {
9143                         surface = rsurface.modelsurfaces + surfacelist[j];
9144                         if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
9145                                 break;
9146                         texturesurfacelist[texturenumsurfaces++] = surface;
9147                 }
9148                 // render the range of surfaces
9149                 if (ent == r_refdef.scene.worldentity)
9150                         R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
9151                 else
9152                         R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
9153         }
9154         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
9155         GL_AlphaTest(false);
9156 }
9157
9158 static void R_ProcessTransparentTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, const entity_render_t *queueentity)
9159 {
9160         // transparent surfaces get pushed off into the transparent queue
9161         int surfacelistindex;
9162         const msurface_t *surface;
9163         vec3_t tempcenter, center;
9164         for (surfacelistindex = 0;surfacelistindex < texturenumsurfaces;surfacelistindex++)
9165         {
9166                 surface = texturesurfacelist[surfacelistindex];
9167                 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
9168                 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
9169                 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
9170                 Matrix4x4_Transform(&rsurface.matrix, tempcenter, center);
9171                 if (queueentity->transparent_offset) // transparent offset
9172                 {
9173                         center[0] += r_refdef.view.forward[0]*queueentity->transparent_offset;
9174                         center[1] += r_refdef.view.forward[1]*queueentity->transparent_offset;
9175                         center[2] += r_refdef.view.forward[2]*queueentity->transparent_offset;
9176                 }
9177                 R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_refdef.view.origin : center, R_DrawSurface_TransparentCallback, queueentity, surface - rsurface.modelsurfaces, rsurface.rtlight);
9178         }
9179 }
9180
9181 static void R_ProcessWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, qboolean prepass)
9182 {
9183         const entity_render_t *queueentity = r_refdef.scene.worldentity;
9184         CHECKGLERROR
9185         if (depthonly)
9186         {
9187                 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
9188                         return;
9189                 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
9190                         return;
9191                 RSurf_SetupDepthAndCulling();
9192                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9193                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9194         }
9195         else if (prepass)
9196         {
9197                 if (!rsurface.texture->currentnumlayers)
9198                         return;
9199                 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
9200                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
9201                 else
9202                         R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
9203         }
9204         else if (r_showsurfaces.integer && !r_refdef.view.showdebug && !prepass)
9205         {
9206                 RSurf_SetupDepthAndCulling();
9207                 GL_AlphaTest(false);
9208                 R_Mesh_ColorPointer(NULL, 0, 0);
9209                 R_Mesh_ResetTextureState();
9210                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9211                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9212                 GL_DepthMask(true);
9213                 GL_BlendFunc(GL_ONE, GL_ZERO);
9214                 GL_Color(0, 0, 0, 1);
9215                 GL_DepthTest(writedepth);
9216                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9217         }
9218         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3 && !prepass)
9219         {
9220                 RSurf_SetupDepthAndCulling();
9221                 GL_AlphaTest(false);
9222                 R_Mesh_ColorPointer(NULL, 0, 0);
9223                 R_Mesh_ResetTextureState();
9224                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9225                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9226                 GL_DepthMask(true);
9227                 GL_BlendFunc(GL_ONE, GL_ZERO);
9228                 GL_DepthTest(true);
9229                 RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
9230         }
9231         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
9232                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
9233         else if (!rsurface.texture->currentnumlayers)
9234                 return;
9235         else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
9236         {
9237                 // in the deferred case, transparent surfaces were queued during prepass
9238                 if (!r_shadow_usingdeferredprepass)
9239                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
9240         }
9241         else
9242         {
9243                 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
9244                 R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
9245         }
9246         CHECKGLERROR
9247 }
9248
9249 void R_QueueWorldSurfaceList(int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
9250 {
9251         int i, j;
9252         texture_t *texture;
9253         // break the surface list down into batches by texture and use of lightmapping
9254         for (i = 0;i < numsurfaces;i = j)
9255         {
9256                 j = i + 1;
9257                 // texture is the base texture pointer, rsurface.texture is the
9258                 // current frame/skin the texture is directing us to use (for example
9259                 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
9260                 // use skin 1 instead)
9261                 texture = surfacelist[i]->texture;
9262                 rsurface.texture = R_GetCurrentTexture(texture);
9263                 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL && !depthonly && !prepass;
9264                 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
9265                 {
9266                         // if this texture is not the kind we want, skip ahead to the next one
9267                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
9268                                 ;
9269                         continue;
9270                 }
9271                 // simply scan ahead until we find a different texture or lightmap state
9272                 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
9273                         ;
9274                 // render the range of surfaces
9275                 R_ProcessWorldTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, prepass);
9276         }
9277 }
9278
9279 static void R_ProcessModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, const entity_render_t *queueentity, qboolean prepass)
9280 {
9281         CHECKGLERROR
9282         if (depthonly)
9283         {
9284                 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
9285                         return;
9286                 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
9287                         return;
9288                 RSurf_SetupDepthAndCulling();
9289                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9290                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9291         }
9292         else if (prepass)
9293         {
9294                 if (!rsurface.texture->currentnumlayers)
9295                         return;
9296                 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
9297                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
9298                 else
9299                         R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
9300         }
9301         else if (r_showsurfaces.integer && !r_refdef.view.showdebug)
9302         {
9303                 RSurf_SetupDepthAndCulling();
9304                 GL_AlphaTest(false);
9305                 R_Mesh_ColorPointer(NULL, 0, 0);
9306                 R_Mesh_ResetTextureState();
9307                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9308                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9309                 GL_DepthMask(true);
9310                 GL_BlendFunc(GL_ONE, GL_ZERO);
9311                 GL_Color(0, 0, 0, 1);
9312                 GL_DepthTest(writedepth);
9313                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9314         }
9315         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
9316         {
9317                 RSurf_SetupDepthAndCulling();
9318                 GL_AlphaTest(false);
9319                 R_Mesh_ColorPointer(NULL, 0, 0);
9320                 R_Mesh_ResetTextureState();
9321                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9322                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9323                 GL_DepthMask(true);
9324                 GL_BlendFunc(GL_ONE, GL_ZERO);
9325                 GL_DepthTest(true);
9326                 RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
9327         }
9328         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
9329                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
9330         else if (!rsurface.texture->currentnumlayers)
9331                 return;
9332         else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
9333         {
9334                 // in the deferred case, transparent surfaces were queued during prepass
9335                 if (!r_shadow_usingdeferredprepass)
9336                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
9337         }
9338         else
9339         {
9340                 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
9341                 R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
9342         }
9343         CHECKGLERROR
9344 }
9345
9346 void R_QueueModelSurfaceList(entity_render_t *ent, int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
9347 {
9348         int i, j;
9349         texture_t *texture;
9350         // break the surface list down into batches by texture and use of lightmapping
9351         for (i = 0;i < numsurfaces;i = j)
9352         {
9353                 j = i + 1;
9354                 // texture is the base texture pointer, rsurface.texture is the
9355                 // current frame/skin the texture is directing us to use (for example
9356                 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
9357                 // use skin 1 instead)
9358                 texture = surfacelist[i]->texture;
9359                 rsurface.texture = R_GetCurrentTexture(texture);
9360                 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL && !depthonly && !prepass;
9361                 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
9362                 {
9363                         // if this texture is not the kind we want, skip ahead to the next one
9364                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
9365                                 ;
9366                         continue;
9367                 }
9368                 // simply scan ahead until we find a different texture or lightmap state
9369                 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
9370                         ;
9371                 // render the range of surfaces
9372                 R_ProcessModelTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, ent, prepass);
9373         }
9374 }
9375
9376 float locboxvertex3f[6*4*3] =
9377 {
9378         1,0,1, 1,0,0, 1,1,0, 1,1,1,
9379         0,1,1, 0,1,0, 0,0,0, 0,0,1,
9380         1,1,1, 1,1,0, 0,1,0, 0,1,1,
9381         0,0,1, 0,0,0, 1,0,0, 1,0,1,
9382         0,0,1, 1,0,1, 1,1,1, 0,1,1,
9383         1,0,0, 0,0,0, 0,1,0, 1,1,0
9384 };
9385
9386 unsigned short locboxelements[6*2*3] =
9387 {
9388          0, 1, 2, 0, 2, 3,
9389          4, 5, 6, 4, 6, 7,
9390          8, 9,10, 8,10,11,
9391         12,13,14, 12,14,15,
9392         16,17,18, 16,18,19,
9393         20,21,22, 20,22,23
9394 };
9395
9396 void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
9397 {
9398         int i, j;
9399         cl_locnode_t *loc = (cl_locnode_t *)ent;
9400         vec3_t mins, size;
9401         float vertex3f[6*4*3];
9402         CHECKGLERROR
9403         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9404         GL_DepthMask(false);
9405         GL_DepthRange(0, 1);
9406         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
9407         GL_DepthTest(true);
9408         GL_CullFace(GL_NONE);
9409         R_EntityMatrix(&identitymatrix);
9410
9411         R_Mesh_VertexPointer(vertex3f, 0, 0);
9412         R_Mesh_ColorPointer(NULL, 0, 0);
9413         R_Mesh_ResetTextureState();
9414         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9415
9416         i = surfacelist[0];
9417         GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_refdef.view.colorscale,
9418                          ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_refdef.view.colorscale,
9419                          ((i & 0x01C0) >> 6) * (1.0f / 7.0f) * r_refdef.view.colorscale,
9420                         surfacelist[0] < 0 ? 0.5f : 0.125f);
9421
9422         if (VectorCompare(loc->mins, loc->maxs))
9423         {
9424                 VectorSet(size, 2, 2, 2);
9425                 VectorMA(loc->mins, -0.5f, size, mins);
9426         }
9427         else
9428         {
9429                 VectorCopy(loc->mins, mins);
9430                 VectorSubtract(loc->maxs, loc->mins, size);
9431         }
9432
9433         for (i = 0;i < 6*4*3;)
9434                 for (j = 0;j < 3;j++, i++)
9435                         vertex3f[i] = mins[j] + size[j] * locboxvertex3f[i];
9436
9437         R_Mesh_Draw(0, 6*4, 0, 6*2, NULL, locboxelements, 0, 0);
9438 }
9439
9440 void R_DrawLocs(void)
9441 {
9442         int index;
9443         cl_locnode_t *loc, *nearestloc;
9444         vec3_t center;
9445         nearestloc = CL_Locs_FindNearest(cl.movement_origin);
9446         for (loc = cl.locnodes, index = 0;loc;loc = loc->next, index++)
9447         {
9448                 VectorLerp(loc->mins, 0.5f, loc->maxs, center);
9449                 R_MeshQueue_AddTransparent(center, R_DrawLoc_Callback, (entity_render_t *)loc, loc == nearestloc ? -1 : index, NULL);
9450         }
9451 }
9452
9453 void R_DecalSystem_Reset(decalsystem_t *decalsystem)
9454 {
9455         if (decalsystem->decals)
9456                 Mem_Free(decalsystem->decals);
9457         memset(decalsystem, 0, sizeof(*decalsystem));
9458 }
9459
9460 static void R_DecalSystem_SpawnTriangle(decalsystem_t *decalsystem, const float *v0, const float *v1, const float *v2, const float *t0, const float *t1, const float *t2, const float *c0, const float *c1, const float *c2, int triangleindex, int surfaceindex, int decalsequence)
9461 {
9462         tridecal_t *decal;
9463         tridecal_t *decals;
9464         int i;
9465         int maxdecals;
9466
9467         // expand or initialize the system
9468         if (decalsystem->maxdecals <= decalsystem->numdecals)
9469         {
9470                 decalsystem_t old = *decalsystem;
9471                 qboolean useshortelements;
9472                 decalsystem->maxdecals = max(16, decalsystem->maxdecals * 2);
9473                 useshortelements = decalsystem->maxdecals * 3 <= 65536;
9474                 decalsystem->decals = Mem_Alloc(cls.levelmempool, decalsystem->maxdecals * (sizeof(tridecal_t) + sizeof(float[3][3]) + sizeof(float[3][2]) + sizeof(float[3][4]) + sizeof(int[3]) + (useshortelements ? sizeof(unsigned short[3]) : 0)));
9475                 decalsystem->color4f = (float *)(decalsystem->decals + decalsystem->maxdecals);
9476                 decalsystem->texcoord2f = (float *)(decalsystem->color4f + decalsystem->maxdecals*12);
9477                 decalsystem->vertex3f = (float *)(decalsystem->texcoord2f + decalsystem->maxdecals*6);
9478                 decalsystem->element3i = (int *)(decalsystem->vertex3f + decalsystem->maxdecals*9);
9479                 decalsystem->element3s = (useshortelements ? ((unsigned short *)(decalsystem->element3i + decalsystem->maxdecals*3)) : NULL);
9480                 if (decalsystem->numdecals)
9481                         memcpy(decalsystem->decals, old.decals, decalsystem->numdecals * sizeof(tridecal_t));
9482                 if (old.decals)
9483                         Mem_Free(old.decals);
9484                 for (i = 0;i < decalsystem->maxdecals*3;i++)
9485                         decalsystem->element3i[i] = i;
9486                 if (useshortelements)
9487                         for (i = 0;i < decalsystem->maxdecals*3;i++)
9488                                 decalsystem->element3s[i] = i;
9489         }
9490
9491         // grab a decal and search for another free slot for the next one
9492         maxdecals = decalsystem->maxdecals;
9493         decals = decalsystem->decals;
9494         decal = decalsystem->decals + (i = decalsystem->freedecal++);
9495         for (i = decalsystem->freedecal;i < decalsystem->numdecals && decals[i].color4ub[0][3];i++)
9496                 ;
9497         decalsystem->freedecal = i;
9498         if (decalsystem->numdecals <= i)
9499                 decalsystem->numdecals = i + 1;
9500
9501         // initialize the decal
9502         decal->lived = 0;
9503         decal->triangleindex = triangleindex;
9504         decal->surfaceindex = surfaceindex;
9505         decal->decalsequence = decalsequence;
9506         decal->color4ub[0][0] = (unsigned char)(c0[0]*255.0f);
9507         decal->color4ub[0][1] = (unsigned char)(c0[1]*255.0f);
9508         decal->color4ub[0][2] = (unsigned char)(c0[2]*255.0f);
9509         decal->color4ub[0][3] = 255;
9510         decal->color4ub[1][0] = (unsigned char)(c1[0]*255.0f);
9511         decal->color4ub[1][1] = (unsigned char)(c1[1]*255.0f);
9512         decal->color4ub[1][2] = (unsigned char)(c1[2]*255.0f);
9513         decal->color4ub[1][3] = 255;
9514         decal->color4ub[2][0] = (unsigned char)(c2[0]*255.0f);
9515         decal->color4ub[2][1] = (unsigned char)(c2[1]*255.0f);
9516         decal->color4ub[2][2] = (unsigned char)(c2[2]*255.0f);
9517         decal->color4ub[2][3] = 255;
9518         decal->vertex3f[0][0] = v0[0];
9519         decal->vertex3f[0][1] = v0[1];
9520         decal->vertex3f[0][2] = v0[2];
9521         decal->vertex3f[1][0] = v1[0];
9522         decal->vertex3f[1][1] = v1[1];
9523         decal->vertex3f[1][2] = v1[2];
9524         decal->vertex3f[2][0] = v2[0];
9525         decal->vertex3f[2][1] = v2[1];
9526         decal->vertex3f[2][2] = v2[2];
9527         decal->texcoord2f[0][0] = t0[0];
9528         decal->texcoord2f[0][1] = t0[1];
9529         decal->texcoord2f[1][0] = t1[0];
9530         decal->texcoord2f[1][1] = t1[1];
9531         decal->texcoord2f[2][0] = t2[0];
9532         decal->texcoord2f[2][1] = t2[1];
9533 }
9534
9535 extern cvar_t cl_decals_bias;
9536 extern cvar_t cl_decals_models;
9537 extern cvar_t cl_decals_newsystem_intensitymultiplier;
9538 static void R_DecalSystem_SplatEntity(entity_render_t *ent, const vec3_t worldorigin, const vec3_t worldnormal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float worldsize, int decalsequence)
9539 {
9540         matrix4x4_t projection;
9541         decalsystem_t *decalsystem;
9542         qboolean dynamic;
9543         dp_model_t *model;
9544         const float *vertex3f;
9545         const msurface_t *surface;
9546         const msurface_t *surfaces;
9547         const int *surfacelist;
9548         const texture_t *texture;
9549         int numvertices;
9550         int numtriangles;
9551         int numsurfacelist;
9552         int surfacelistindex;
9553         int surfaceindex;
9554         int triangleindex;
9555         int decalsurfaceindex;
9556         int cornerindex;
9557         int index;
9558         int numpoints;
9559         const int *e;
9560         float localorigin[3];
9561         float localnormal[3];
9562         float localmins[3];
9563         float localmaxs[3];
9564         float localsize;
9565         float ilocalsize;
9566         float v[9][3];
9567         float tc[9][2];
9568         float c[9][4];
9569         //float normal[3];
9570         float planes[6][4];
9571         float f;
9572         float points[2][9][3];
9573         float angles[3];
9574         float temp[3];
9575
9576         decalsystem = &ent->decalsystem;
9577         model = ent->model;
9578         if (!model || !ent->allowdecals || ent->alpha < 1 || (ent->flags & (RENDER_ADDITIVE | RENDER_NODEPTHTEST)))
9579         {
9580                 R_DecalSystem_Reset(&ent->decalsystem);
9581                 return;
9582         }
9583
9584         if (!model->brush.data_nodes && !cl_decals_models.integer)
9585         {
9586                 if (decalsystem->model)
9587                         R_DecalSystem_Reset(decalsystem);
9588                 return;
9589         }
9590
9591         if (decalsystem->model != model)
9592                 R_DecalSystem_Reset(decalsystem);
9593         decalsystem->model = model;
9594
9595         RSurf_ActiveModelEntity(ent, false, false, false);
9596
9597         Matrix4x4_Transform(&rsurface.inversematrix, worldorigin, localorigin);
9598         Matrix4x4_Transform3x3(&rsurface.inversematrix, worldnormal, localnormal);
9599         VectorNormalize(localnormal);
9600         localsize = worldsize*rsurface.inversematrixscale;
9601         ilocalsize = 1.0f / localsize;
9602         localmins[0] = localorigin[0] - localsize;
9603         localmins[1] = localorigin[1] - localsize;
9604         localmins[2] = localorigin[2] - localsize;
9605         localmaxs[0] = localorigin[0] + localsize;
9606         localmaxs[1] = localorigin[1] + localsize;
9607         localmaxs[2] = localorigin[2] + localsize;
9608
9609         //VectorCopy(localnormal, planes[4]);
9610         //VectorVectors(planes[4], planes[2], planes[0]);
9611         AnglesFromVectors(angles, localnormal, NULL, false);
9612         AngleVectors(angles, planes[0], planes[2], planes[4]);
9613         VectorNegate(planes[0], planes[1]);
9614         VectorNegate(planes[2], planes[3]);
9615         VectorNegate(planes[4], planes[5]);
9616         planes[0][3] = DotProduct(planes[0], localorigin) - localsize;
9617         planes[1][3] = DotProduct(planes[1], localorigin) - localsize;
9618         planes[2][3] = DotProduct(planes[2], localorigin) - localsize;
9619         planes[3][3] = DotProduct(planes[3], localorigin) - localsize;
9620         planes[4][3] = DotProduct(planes[4], localorigin) - localsize;
9621         planes[5][3] = DotProduct(planes[5], localorigin) - localsize;
9622
9623 #if 1
9624 // works
9625 {
9626         matrix4x4_t forwardprojection;
9627         Matrix4x4_CreateFromQuakeEntity(&forwardprojection, localorigin[0], localorigin[1], localorigin[2], angles[0], angles[1], angles[2], localsize);
9628         Matrix4x4_Invert_Simple(&projection, &forwardprojection);
9629 }
9630 #else
9631 // broken
9632 {
9633         float projectionvector[4][3];
9634         VectorScale(planes[0], ilocalsize, projectionvector[0]);
9635         VectorScale(planes[2], ilocalsize, projectionvector[1]);
9636         VectorScale(planes[4], ilocalsize, projectionvector[2]);
9637         projectionvector[0][0] = planes[0][0] * ilocalsize;
9638         projectionvector[0][1] = planes[1][0] * ilocalsize;
9639         projectionvector[0][2] = planes[2][0] * ilocalsize;
9640         projectionvector[1][0] = planes[0][1] * ilocalsize;
9641         projectionvector[1][1] = planes[1][1] * ilocalsize;
9642         projectionvector[1][2] = planes[2][1] * ilocalsize;
9643         projectionvector[2][0] = planes[0][2] * ilocalsize;
9644         projectionvector[2][1] = planes[1][2] * ilocalsize;
9645         projectionvector[2][2] = planes[2][2] * ilocalsize;
9646         projectionvector[3][0] = -(localorigin[0]*projectionvector[0][0]+localorigin[1]*projectionvector[1][0]+localorigin[2]*projectionvector[2][0]);
9647         projectionvector[3][1] = -(localorigin[0]*projectionvector[0][1]+localorigin[1]*projectionvector[1][1]+localorigin[2]*projectionvector[2][1]);
9648         projectionvector[3][2] = -(localorigin[0]*projectionvector[0][2]+localorigin[1]*projectionvector[1][2]+localorigin[2]*projectionvector[2][2]);
9649         Matrix4x4_FromVectors(&projection, projectionvector[0], projectionvector[1], projectionvector[2], projectionvector[3]);
9650 }
9651 #endif
9652
9653         dynamic = model->surfmesh.isanimated;
9654         vertex3f = rsurface.modelvertex3f;
9655         numsurfacelist = model->nummodelsurfaces;
9656         surfacelist = model->sortedmodelsurfaces;
9657         surfaces = model->data_surfaces;
9658         for (surfacelistindex = 0;surfacelistindex < numsurfacelist;surfacelistindex++)
9659         {
9660                 surfaceindex = surfacelist[surfacelistindex];
9661                 surface = surfaces + surfaceindex;
9662                 // skip transparent surfaces
9663                 texture = surface->texture;
9664                 if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
9665                         continue;
9666                 if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS)
9667                         continue;
9668                 if (!dynamic && !BoxesOverlap(surface->mins, surface->maxs, localmins, localmaxs))
9669                         continue;
9670                 decalsurfaceindex = ent == r_refdef.scene.worldentity ? surfaceindex : -1;
9671                 numvertices = surface->num_vertices;
9672                 numtriangles = surface->num_triangles;
9673                 for (triangleindex = 0, e = model->surfmesh.data_element3i + 3*surface->num_firsttriangle;triangleindex < numtriangles;triangleindex++, e += 3)
9674                 {
9675                         for (cornerindex = 0;cornerindex < 3;cornerindex++)
9676                         {
9677                                 index = 3*e[cornerindex];
9678                                 VectorCopy(vertex3f + index, v[cornerindex]);
9679                         }
9680                         // cull backfaces
9681                         //TriangleNormal(v[0], v[1], v[2], normal);
9682                         //if (DotProduct(normal, localnormal) < 0.0f)
9683                         //      continue;
9684                         // clip by each of the box planes formed from the projection matrix
9685                         // if anything survives, we emit the decal
9686                         numpoints = PolygonF_Clip(3        , v[0]        , planes[0][0], planes[0][1], planes[0][2], planes[0][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), points[1][0]);
9687                         if (numpoints < 3)
9688                                 continue;
9689                         numpoints = PolygonF_Clip(numpoints, points[1][0], planes[1][0], planes[1][1], planes[1][2], planes[1][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), points[0][0]);
9690                         if (numpoints < 3)
9691                                 continue;
9692                         numpoints = PolygonF_Clip(numpoints, points[0][0], planes[2][0], planes[2][1], planes[2][2], planes[2][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), points[1][0]);
9693                         if (numpoints < 3)
9694                                 continue;
9695                         numpoints = PolygonF_Clip(numpoints, points[1][0], planes[3][0], planes[3][1], planes[3][2], planes[3][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), points[0][0]);
9696                         if (numpoints < 3)
9697                                 continue;
9698                         numpoints = PolygonF_Clip(numpoints, points[0][0], planes[4][0], planes[4][1], planes[4][2], planes[4][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), points[1][0]);
9699                         if (numpoints < 3)
9700                                 continue;
9701                         numpoints = PolygonF_Clip(numpoints, points[1][0], planes[5][0], planes[5][1], planes[5][2], planes[5][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), v[0]);
9702                         if (numpoints < 3)
9703                                 continue;
9704                         // some part of the triangle survived, so we have to accept it...
9705                         if (dynamic)
9706                         {
9707                                 // dynamic always uses the original triangle
9708                                 numpoints = 3;
9709                                 for (cornerindex = 0;cornerindex < 3;cornerindex++)
9710                                 {
9711                                         index = 3*e[cornerindex];
9712                                         VectorCopy(vertex3f + index, v[cornerindex]);
9713                                 }
9714                         }
9715                         for (cornerindex = 0;cornerindex < numpoints;cornerindex++)
9716                         {
9717                                 // convert vertex positions to texcoords
9718                                 Matrix4x4_Transform(&projection, v[cornerindex], temp);
9719                                 tc[cornerindex][0] = (temp[1]+1.0f)*0.5f * (s2-s1) + s1;
9720                                 tc[cornerindex][1] = (temp[2]+1.0f)*0.5f * (t2-t1) + t1;
9721                                 // calculate distance fade from the projection origin
9722                                 f = a * (1.0f-fabs(temp[0])) * cl_decals_newsystem_intensitymultiplier.value;
9723                                 f = bound(0.0f, f, 1.0f);
9724                                 c[cornerindex][0] = r * f;
9725                                 c[cornerindex][1] = g * f;
9726                                 c[cornerindex][2] = b * f;
9727                                 c[cornerindex][3] = 1.0f;
9728                                 //VectorMA(v[cornerindex], cl_decals_bias.value, localnormal, v[cornerindex]);
9729                         }
9730                         if (dynamic)
9731                                 R_DecalSystem_SpawnTriangle(decalsystem, v[0], v[1], v[2], tc[0], tc[1], tc[2], c[0], c[1], c[2], triangleindex+surface->num_firsttriangle, surfaceindex, decalsequence);
9732                         else
9733                                 for (cornerindex = 0;cornerindex < numpoints-2;cornerindex++)
9734                                         R_DecalSystem_SpawnTriangle(decalsystem, v[0], v[cornerindex+1], v[cornerindex+2], tc[0], tc[cornerindex+1], tc[cornerindex+2], c[0], c[cornerindex+1], c[cornerindex+2], -1, surfaceindex, decalsequence);
9735                 }
9736         }
9737 }
9738
9739 // do not call this outside of rendering code - use R_DecalSystem_SplatEntities instead
9740 static void R_DecalSystem_ApplySplatEntities(const vec3_t worldorigin, const vec3_t worldnormal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float worldsize, int decalsequence)
9741 {
9742         int renderentityindex;
9743         float worldmins[3];
9744         float worldmaxs[3];
9745         entity_render_t *ent;
9746
9747         if (!cl_decals_newsystem.integer)
9748                 return;
9749
9750         worldmins[0] = worldorigin[0] - worldsize;
9751         worldmins[1] = worldorigin[1] - worldsize;
9752         worldmins[2] = worldorigin[2] - worldsize;
9753         worldmaxs[0] = worldorigin[0] + worldsize;
9754         worldmaxs[1] = worldorigin[1] + worldsize;
9755         worldmaxs[2] = worldorigin[2] + worldsize;
9756
9757         R_DecalSystem_SplatEntity(r_refdef.scene.worldentity, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
9758
9759         for (renderentityindex = 0;renderentityindex < r_refdef.scene.numentities;renderentityindex++)
9760         {
9761                 ent = r_refdef.scene.entities[renderentityindex];
9762                 if (!BoxesOverlap(ent->mins, ent->maxs, worldmins, worldmaxs))
9763                         continue;
9764
9765                 R_DecalSystem_SplatEntity(ent, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
9766         }
9767 }
9768
9769 typedef struct r_decalsystem_splatqueue_s
9770 {
9771         vec3_t worldorigin;
9772         vec3_t worldnormal;
9773         float color[4];
9774         float tcrange[4];
9775         float worldsize;
9776         int decalsequence;
9777 }
9778 r_decalsystem_splatqueue_t;
9779
9780 int r_decalsystem_numqueued = 0;
9781 #define MAX_DECALSYSTEM_QUEUE 1024
9782 r_decalsystem_splatqueue_t r_decalsystem_queue[MAX_DECALSYSTEM_QUEUE];
9783
9784 void R_DecalSystem_SplatEntities(const vec3_t worldorigin, const vec3_t worldnormal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float worldsize)
9785 {
9786         r_decalsystem_splatqueue_t *queue;
9787
9788         if (!cl_decals_newsystem.integer || r_decalsystem_numqueued == MAX_DECALSYSTEM_QUEUE)
9789                 return;
9790
9791         queue = &r_decalsystem_queue[r_decalsystem_numqueued++];
9792         VectorCopy(worldorigin, queue->worldorigin);
9793         VectorCopy(worldnormal, queue->worldnormal);
9794         Vector4Set(queue->color, r, g, b, a);
9795         Vector4Set(queue->tcrange, s1, t1, s2, t2);
9796         queue->worldsize = worldsize;
9797         queue->decalsequence = cl.decalsequence++;
9798 }
9799
9800 static void R_DecalSystem_ApplySplatEntitiesQueue(void)
9801 {
9802         int i;
9803         r_decalsystem_splatqueue_t *queue;
9804
9805         for (i = 0, queue = r_decalsystem_queue;i < r_decalsystem_numqueued;i++, queue++)
9806                 R_DecalSystem_ApplySplatEntities(queue->worldorigin, queue->worldnormal, queue->color[0], queue->color[1], queue->color[2], queue->color[3], queue->tcrange[0], queue->tcrange[1], queue->tcrange[2], queue->tcrange[3], queue->worldsize, queue->decalsequence);
9807         r_decalsystem_numqueued = 0;
9808 }
9809
9810 extern cvar_t cl_decals_max;
9811 static void R_DrawModelDecals_FadeEntity(entity_render_t *ent)
9812 {
9813         int i;
9814         decalsystem_t *decalsystem = &ent->decalsystem;
9815         int numdecals;
9816         int killsequence;
9817         tridecal_t *decal;
9818         float frametime;
9819         float lifetime;
9820
9821         if (!decalsystem->numdecals)
9822                 return;
9823
9824         if (r_showsurfaces.integer)
9825                 return;
9826
9827         if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
9828         {
9829                 R_DecalSystem_Reset(decalsystem);
9830                 return;
9831         }
9832
9833         killsequence = cl.decalsequence - max(1, cl_decals_max.integer);
9834         lifetime = cl_decals_time.value + cl_decals_fadetime.value;
9835
9836         if (decalsystem->lastupdatetime)
9837                 frametime = (cl.time - decalsystem->lastupdatetime);
9838         else
9839                 frametime = 0;
9840         decalsystem->lastupdatetime = cl.time;
9841         decal = decalsystem->decals;
9842         numdecals = decalsystem->numdecals;
9843
9844         for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
9845         {
9846                 if (decal->color4ub[0][3])
9847                 {
9848                         decal->lived += frametime;
9849                         if (killsequence - decal->decalsequence > 0 || decal->lived >= lifetime)
9850                         {
9851                                 memset(decal, 0, sizeof(*decal));
9852                                 if (decalsystem->freedecal > i)
9853                                         decalsystem->freedecal = i;
9854                         }
9855                 }
9856         }
9857         decal = decalsystem->decals;
9858         while (numdecals > 0 && !decal[numdecals-1].color4ub[0][3])
9859                 numdecals--;
9860
9861         // collapse the array by shuffling the tail decals into the gaps
9862         for (;;)
9863         {
9864                 while (decalsystem->freedecal < numdecals && decal[decalsystem->freedecal].color4ub[0][3])
9865                         decalsystem->freedecal++;
9866                 if (decalsystem->freedecal == numdecals)
9867                         break;
9868                 decal[decalsystem->freedecal] = decal[--numdecals];
9869         }
9870
9871         decalsystem->numdecals = numdecals;
9872
9873         if (numdecals <= 0)
9874         {
9875                 // if there are no decals left, reset decalsystem
9876                 R_DecalSystem_Reset(decalsystem);
9877         }
9878 }
9879
9880 extern skinframe_t *decalskinframe;
9881 static void R_DrawModelDecals_Entity(entity_render_t *ent)
9882 {
9883         int i;
9884         decalsystem_t *decalsystem = &ent->decalsystem;
9885         int numdecals;
9886         tridecal_t *decal;
9887         float fadedelay;
9888         float faderate;
9889         float alpha;
9890         float *v3f;
9891         float *c4f;
9892         float *t2f;
9893         const int *e;
9894         const unsigned char *surfacevisible = ent == r_refdef.scene.worldentity ? r_refdef.viewcache.world_surfacevisible : NULL;
9895         int numtris = 0;
9896
9897         numdecals = decalsystem->numdecals;
9898         if (!numdecals)
9899                 return;
9900
9901         if (r_showsurfaces.integer)
9902                 return;
9903
9904         if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
9905         {
9906                 R_DecalSystem_Reset(decalsystem);
9907                 return;
9908         }
9909
9910         // if the model is static it doesn't matter what value we give for
9911         // wantnormals and wanttangents, so this logic uses only rules applicable
9912         // to a model, knowing that they are meaningless otherwise
9913         if (ent == r_refdef.scene.worldentity)
9914                 RSurf_ActiveWorldEntity();
9915         else
9916                 RSurf_ActiveModelEntity(ent, false, false, false);
9917
9918         decalsystem->lastupdatetime = cl.time;
9919         decal = decalsystem->decals;
9920
9921         fadedelay = cl_decals_time.value;
9922         faderate = 1.0f / max(0.001f, cl_decals_fadetime.value);
9923
9924         // update vertex positions for animated models
9925         v3f = decalsystem->vertex3f;
9926         c4f = decalsystem->color4f;
9927         t2f = decalsystem->texcoord2f;
9928         for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
9929         {
9930                 if (!decal->color4ub[0][3])
9931                         continue;
9932
9933                 if (surfacevisible && !surfacevisible[decal->surfaceindex])
9934                         continue;
9935
9936                 // update color values for fading decals
9937                 if (decal->lived >= cl_decals_time.value)
9938                 {
9939                         alpha = 1 - faderate * (decal->lived - cl_decals_time.value);
9940                         alpha *= (1.0f/255.0f);
9941                 }
9942                 else
9943                         alpha = 1.0f/255.0f;
9944
9945                 c4f[ 0] = decal->color4ub[0][0] * alpha;
9946                 c4f[ 1] = decal->color4ub[0][1] * alpha;
9947                 c4f[ 2] = decal->color4ub[0][2] * alpha;
9948                 c4f[ 3] = 1;
9949                 c4f[ 4] = decal->color4ub[1][0] * alpha;
9950                 c4f[ 5] = decal->color4ub[1][1] * alpha;
9951                 c4f[ 6] = decal->color4ub[1][2] * alpha;
9952                 c4f[ 7] = 1;
9953                 c4f[ 8] = decal->color4ub[2][0] * alpha;
9954                 c4f[ 9] = decal->color4ub[2][1] * alpha;
9955                 c4f[10] = decal->color4ub[2][2] * alpha;
9956                 c4f[11] = 1;
9957
9958                 t2f[0] = decal->texcoord2f[0][0];
9959                 t2f[1] = decal->texcoord2f[0][1];
9960                 t2f[2] = decal->texcoord2f[1][0];
9961                 t2f[3] = decal->texcoord2f[1][1];
9962                 t2f[4] = decal->texcoord2f[2][0];
9963                 t2f[5] = decal->texcoord2f[2][1];
9964
9965                 // update vertex positions for animated models
9966                 if (decal->triangleindex >= 0 && decal->triangleindex < rsurface.modelnum_triangles)
9967                 {
9968                         e = rsurface.modelelement3i + 3*decal->triangleindex;
9969                         VectorCopy(rsurface.vertex3f + 3*e[0], v3f);
9970                         VectorCopy(rsurface.vertex3f + 3*e[1], v3f + 3);
9971                         VectorCopy(rsurface.vertex3f + 3*e[2], v3f + 6);
9972                 }
9973                 else
9974                 {
9975                         VectorCopy(decal->vertex3f[0], v3f);
9976                         VectorCopy(decal->vertex3f[1], v3f + 3);
9977                         VectorCopy(decal->vertex3f[2], v3f + 6);
9978                 }
9979
9980                 v3f += 9;
9981                 c4f += 12;
9982                 t2f += 6;
9983                 numtris++;
9984         }
9985
9986         if (numtris > 0)
9987         {
9988                 r_refdef.stats.drawndecals += numtris;
9989
9990                 if (r_refdef.fogenabled)
9991                 {
9992                         switch(vid.renderpath)
9993                         {
9994                         case RENDERPATH_GL20:
9995                         case RENDERPATH_CGGL:
9996                         case RENDERPATH_GL13:
9997                         case RENDERPATH_GL11:
9998                                 for (i = 0, v3f = decalsystem->vertex3f, c4f = decalsystem->color4f;i < numtris*3;i++, v3f += 3, c4f += 4)
9999                                 {
10000                                         alpha = RSurf_FogVertex(v3f);
10001                                         c4f[0] *= alpha;
10002                                         c4f[1] *= alpha;
10003                                         c4f[2] *= alpha;
10004                                 }
10005                                 break;
10006                         }
10007                 }
10008
10009                 // now render the decals all at once
10010                 // (this assumes they all use one particle font texture!)
10011                 RSurf_ActiveCustomEntity(&rsurface.matrix, &rsurface.inversematrix, rsurface.ent_flags, rsurface.ent_shadertime, 1, 1, 1, 1, numdecals*3, decalsystem->vertex3f, decalsystem->texcoord2f, NULL, NULL, NULL, decalsystem->color4f, numtris, decalsystem->element3i, decalsystem->element3s, false, false);
10012                 R_Mesh_ResetTextureState();
10013                 R_Mesh_VertexPointer(decalsystem->vertex3f, 0, 0);
10014                 R_Mesh_TexCoordPointer(0, 2, decalsystem->texcoord2f, 0, 0);
10015                 R_Mesh_ColorPointer(decalsystem->color4f, 0, 0);
10016                 GL_DepthMask(false);
10017                 GL_DepthRange(0, 1);
10018                 GL_PolygonOffset(rsurface.basepolygonfactor + r_polygonoffset_decals_factor.value, rsurface.basepolygonoffset + r_polygonoffset_decals_offset.value);
10019                 GL_DepthTest(true);
10020                 GL_CullFace(GL_NONE);
10021                 GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
10022                 R_SetupShader_Generic(decalskinframe->base, NULL, GL_MODULATE, 1);
10023                 GL_LockArrays(0, numtris * 3);
10024                 R_Mesh_Draw(0, numtris * 3, 0, numtris, decalsystem->element3i, decalsystem->element3s, 0, 0);
10025                 GL_LockArrays(0, 0);
10026         }
10027 }
10028
10029 static void R_DrawModelDecals(void)
10030 {
10031         int i, numdecals;
10032
10033         // fade faster when there are too many decals
10034         numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
10035         for (i = 0;i < r_refdef.scene.numentities;i++)
10036                 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
10037
10038         R_DrawModelDecals_FadeEntity(r_refdef.scene.worldentity);
10039         for (i = 0;i < r_refdef.scene.numentities;i++)
10040                 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
10041                         R_DrawModelDecals_FadeEntity(r_refdef.scene.entities[i]);
10042
10043         R_DecalSystem_ApplySplatEntitiesQueue();
10044
10045         numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
10046         for (i = 0;i < r_refdef.scene.numentities;i++)
10047                 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
10048
10049         r_refdef.stats.totaldecals += numdecals;
10050
10051         if (r_showsurfaces.integer)
10052                 return;
10053
10054         R_DrawModelDecals_Entity(r_refdef.scene.worldentity);
10055
10056         for (i = 0;i < r_refdef.scene.numentities;i++)
10057         {
10058                 if (!r_refdef.viewcache.entityvisible[i])
10059                         continue;
10060                 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
10061                         R_DrawModelDecals_Entity(r_refdef.scene.entities[i]);
10062         }
10063 }
10064
10065 void R_DrawDebugModel(void)
10066 {
10067         entity_render_t *ent = rsurface.entity;
10068         int i, j, k, l, flagsmask;
10069         const int *elements;
10070         q3mbrush_t *brush;
10071         const msurface_t *surface;
10072         dp_model_t *model = ent->model;
10073         vec3_t v;
10074
10075         flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WALL;
10076
10077         R_Mesh_ColorPointer(NULL, 0, 0);
10078         R_Mesh_ResetTextureState();
10079         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
10080         GL_DepthRange(0, 1);
10081         GL_DepthTest(!r_showdisabledepthtest.integer);
10082         GL_DepthMask(false);
10083         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
10084
10085         if (r_showcollisionbrushes.value > 0 && model->brush.num_brushes)
10086         {
10087                 GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
10088                 for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
10089                 {
10090                         if (brush->colbrushf && brush->colbrushf->numtriangles)
10091                         {
10092                                 R_Mesh_VertexPointer(brush->colbrushf->points->v, 0, 0);
10093                                 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);
10094                                 R_Mesh_Draw(0, brush->colbrushf->numpoints, 0, brush->colbrushf->numtriangles, brush->colbrushf->elements, NULL, 0, 0);
10095                         }
10096                 }
10097                 for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
10098                 {
10099                         if (surface->num_collisiontriangles)
10100                         {
10101                                 R_Mesh_VertexPointer(surface->data_collisionvertex3f, 0, 0);
10102                                 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);
10103                                 R_Mesh_Draw(0, surface->num_collisionvertices, 0, surface->num_collisiontriangles, surface->data_collisionelement3i, NULL, 0, 0);
10104                         }
10105                 }
10106         }
10107
10108         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
10109
10110         if (r_showtris.integer || r_shownormals.integer)
10111         {
10112                 if (r_showdisabledepthtest.integer)
10113                 {
10114                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
10115                         GL_DepthMask(false);
10116                 }
10117                 else
10118                 {
10119                         GL_BlendFunc(GL_ONE, GL_ZERO);
10120                         GL_DepthMask(true);
10121                 }
10122                 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
10123                 {
10124                         if (ent == r_refdef.scene.worldentity && !r_refdef.viewcache.world_surfacevisible[j])
10125                                 continue;
10126                         rsurface.texture = R_GetCurrentTexture(surface->texture);
10127                         if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
10128                         {
10129                                 RSurf_PrepareVerticesForBatch(true, true, 1, &surface);
10130                                 if (r_showtris.value > 0)
10131                                 {
10132                                         if (!rsurface.texture->currentlayers->depthmask)
10133                                                 GL_Color(r_refdef.view.colorscale, 0, 0, r_showtris.value);
10134                                         else if (ent == r_refdef.scene.worldentity)
10135                                                 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, r_showtris.value);
10136                                         else
10137                                                 GL_Color(0, r_refdef.view.colorscale, 0, r_showtris.value);
10138                                         elements = (model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);
10139                                         R_Mesh_VertexPointer(rsurface.vertex3f, 0, 0);
10140                                         R_Mesh_ColorPointer(NULL, 0, 0);
10141                                         R_Mesh_TexCoordPointer(0, 0, NULL, 0, 0);
10142                                         qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
10143                                         //R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, model->surfmesh.data_element3i, NULL, 0, 0);
10144                                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
10145                                         qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
10146                                         CHECKGLERROR
10147                                 }
10148                                 if (r_shownormals.value < 0)
10149                                 {
10150                                         qglBegin(GL_LINES);
10151                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
10152                                         {
10153                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
10154                                                 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
10155                                                 qglVertex3f(v[0], v[1], v[2]);
10156                                                 VectorMA(v, -r_shownormals.value, rsurface.svector3f + l * 3, v);
10157                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
10158                                                 qglVertex3f(v[0], v[1], v[2]);
10159                                         }
10160                                         qglEnd();
10161                                         CHECKGLERROR
10162                                 }
10163                                 if (r_shownormals.value > 0)
10164                                 {
10165                                         qglBegin(GL_LINES);
10166                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
10167                                         {
10168                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
10169                                                 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
10170                                                 qglVertex3f(v[0], v[1], v[2]);
10171                                                 VectorMA(v, r_shownormals.value, rsurface.svector3f + l * 3, v);
10172                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
10173                                                 qglVertex3f(v[0], v[1], v[2]);
10174                                         }
10175                                         qglEnd();
10176                                         CHECKGLERROR
10177                                         qglBegin(GL_LINES);
10178                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
10179                                         {
10180                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
10181                                                 GL_Color(0, r_refdef.view.colorscale, 0, 1);
10182                                                 qglVertex3f(v[0], v[1], v[2]);
10183                                                 VectorMA(v, r_shownormals.value, rsurface.tvector3f + l * 3, v);
10184                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
10185                                                 qglVertex3f(v[0], v[1], v[2]);
10186                                         }
10187                                         qglEnd();
10188                                         CHECKGLERROR
10189                                         qglBegin(GL_LINES);
10190                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
10191                                         {
10192                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
10193                                                 GL_Color(0, 0, r_refdef.view.colorscale, 1);
10194                                                 qglVertex3f(v[0], v[1], v[2]);
10195                                                 VectorMA(v, r_shownormals.value, rsurface.normal3f + l * 3, v);
10196                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
10197                                                 qglVertex3f(v[0], v[1], v[2]);
10198                                         }
10199                                         qglEnd();
10200                                         CHECKGLERROR
10201                                 }
10202                         }
10203                 }
10204                 rsurface.texture = NULL;
10205         }
10206 }
10207
10208 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
10209 int r_maxsurfacelist = 0;
10210 const msurface_t **r_surfacelist = NULL;
10211 void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
10212 {
10213         int i, j, endj, f, flagsmask;
10214         texture_t *t;
10215         dp_model_t *model = r_refdef.scene.worldmodel;
10216         msurface_t *surfaces;
10217         unsigned char *update;
10218         int numsurfacelist = 0;
10219         if (model == NULL)
10220                 return;
10221
10222         if (r_maxsurfacelist < model->num_surfaces)
10223         {
10224                 r_maxsurfacelist = model->num_surfaces;
10225                 if (r_surfacelist)
10226                         Mem_Free((msurface_t**)r_surfacelist);
10227                 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
10228         }
10229
10230         RSurf_ActiveWorldEntity();
10231
10232         surfaces = model->data_surfaces;
10233         update = model->brushq1.lightmapupdateflags;
10234
10235         // update light styles on this submodel
10236         if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
10237         {
10238                 model_brush_lightstyleinfo_t *style;
10239                 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
10240                 {
10241                         if (style->value != r_refdef.scene.lightstylevalue[style->style])
10242                         {
10243                                 int *list = style->surfacelist;
10244                                 style->value = r_refdef.scene.lightstylevalue[style->style];
10245                                 for (j = 0;j < style->numsurfaces;j++)
10246                                         update[list[j]] = true;
10247                         }
10248                 }
10249         }
10250
10251         flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
10252
10253         if (debug)
10254         {
10255                 R_DrawDebugModel();
10256                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10257                 return;
10258         }
10259
10260         f = 0;
10261         t = NULL;
10262         rsurface.uselightmaptexture = false;
10263         rsurface.texture = NULL;
10264         rsurface.rtlight = NULL;
10265         numsurfacelist = 0;
10266         // add visible surfaces to draw list
10267         for (i = 0;i < model->nummodelsurfaces;i++)
10268         {
10269                 j = model->sortedmodelsurfaces[i];
10270                 if (r_refdef.viewcache.world_surfacevisible[j])
10271                         r_surfacelist[numsurfacelist++] = surfaces + j;
10272         }
10273         // update lightmaps if needed
10274         if (update)
10275         {
10276                 int updated = 0;
10277                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
10278                 {
10279                         if (r_refdef.viewcache.world_surfacevisible[j])
10280                         {
10281                                 if (update[j])
10282                                 {
10283                                         updated++;
10284                                         R_BuildLightMap(r_refdef.scene.worldentity, surfaces + j);
10285                                 }
10286                         }
10287                 }
10288                 if (updated)
10289                 {
10290                         int count = model->brushq3.num_mergedlightmaps;
10291                         for (i = 0;i < count;i++)
10292                         {
10293                                 if (model->brushq3.data_deluxemaps[i])
10294                                         R_FlushTexture(model->brushq3.data_deluxemaps[i]);
10295                                 if (model->brushq3.data_lightmaps[i])
10296                                         R_FlushTexture(model->brushq3.data_lightmaps[i]);
10297                         }
10298                 }
10299         }
10300         // don't do anything if there were no surfaces
10301         if (!numsurfacelist)
10302         {
10303                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10304                 return;
10305         }
10306         R_QueueWorldSurfaceList(numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
10307         GL_AlphaTest(false);
10308
10309         // add to stats if desired
10310         if (r_speeds.integer && !skysurfaces && !depthonly)
10311         {
10312                 r_refdef.stats.world_surfaces += numsurfacelist;
10313                 for (j = 0;j < numsurfacelist;j++)
10314                         r_refdef.stats.world_triangles += r_surfacelist[j]->num_triangles;
10315         }
10316
10317         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10318 }
10319
10320 void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
10321 {
10322         int i, j, endj, f, flagsmask;
10323         texture_t *t;
10324         dp_model_t *model = ent->model;
10325         msurface_t *surfaces;
10326         unsigned char *update;
10327         int numsurfacelist = 0;
10328         if (model == NULL)
10329                 return;
10330
10331         if (r_maxsurfacelist < model->num_surfaces)
10332         {
10333                 r_maxsurfacelist = model->num_surfaces;
10334                 if (r_surfacelist)
10335                         Mem_Free((msurface_t **)r_surfacelist);
10336                 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
10337         }
10338
10339         // if the model is static it doesn't matter what value we give for
10340         // wantnormals and wanttangents, so this logic uses only rules applicable
10341         // to a model, knowing that they are meaningless otherwise
10342         if (ent == r_refdef.scene.worldentity)
10343                 RSurf_ActiveWorldEntity();
10344         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
10345                 RSurf_ActiveModelEntity(ent, false, false, false);
10346         else if (prepass)
10347                 RSurf_ActiveModelEntity(ent, true, true, true);
10348         else if (depthonly)
10349                 RSurf_ActiveModelEntity(ent, false, false, false);
10350         else
10351         {
10352                 switch (vid.renderpath)
10353                 {
10354                 case RENDERPATH_GL20:
10355                 case RENDERPATH_CGGL:
10356                         RSurf_ActiveModelEntity(ent, true, true, false);
10357                         break;
10358                 case RENDERPATH_GL13:
10359                 case RENDERPATH_GL11:
10360                         RSurf_ActiveModelEntity(ent, true, false, false);
10361                         break;
10362                 }
10363         }
10364
10365         surfaces = model->data_surfaces;
10366         update = model->brushq1.lightmapupdateflags;
10367
10368         // update light styles
10369         if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
10370         {
10371                 model_brush_lightstyleinfo_t *style;
10372                 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
10373                 {
10374                         if (style->value != r_refdef.scene.lightstylevalue[style->style])
10375                         {
10376                                 int *list = style->surfacelist;
10377                                 style->value = r_refdef.scene.lightstylevalue[style->style];
10378                                 for (j = 0;j < style->numsurfaces;j++)
10379                                         update[list[j]] = true;
10380                         }
10381                 }
10382         }
10383
10384         flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
10385
10386         if (debug)
10387         {
10388                 R_DrawDebugModel();
10389                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10390                 return;
10391         }
10392
10393         f = 0;
10394         t = NULL;
10395         rsurface.uselightmaptexture = false;
10396         rsurface.texture = NULL;
10397         rsurface.rtlight = NULL;
10398         numsurfacelist = 0;
10399         // add visible surfaces to draw list
10400         for (i = 0;i < model->nummodelsurfaces;i++)
10401                 r_surfacelist[numsurfacelist++] = surfaces + model->sortedmodelsurfaces[i];
10402         // don't do anything if there were no surfaces
10403         if (!numsurfacelist)
10404         {
10405                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10406                 return;
10407         }
10408         // update lightmaps if needed
10409         if (update)
10410         {
10411                 int updated = 0;
10412                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
10413                 {
10414                         if (update[j])
10415                         {
10416                                 updated++;
10417                                 R_BuildLightMap(ent, surfaces + j);
10418                         }
10419                 }
10420                 if (updated)
10421                 {
10422                         int count = model->brushq3.num_mergedlightmaps;
10423                         for (i = 0;i < count;i++)
10424                         {
10425                                 if (model->brushq3.data_deluxemaps[i])
10426                                         R_FlushTexture(model->brushq3.data_deluxemaps[i]);
10427                                 if (model->brushq3.data_lightmaps[i])
10428                                         R_FlushTexture(model->brushq3.data_lightmaps[i]);
10429                         }
10430                 }
10431         }
10432         if (update)
10433                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
10434                         if (update[j])
10435                                 R_BuildLightMap(ent, surfaces + j);
10436         R_QueueModelSurfaceList(ent, numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
10437         GL_AlphaTest(false);
10438
10439         // add to stats if desired
10440         if (r_speeds.integer && !skysurfaces && !depthonly)
10441         {
10442                 r_refdef.stats.entities_surfaces += numsurfacelist;
10443                 for (j = 0;j < numsurfacelist;j++)
10444                         r_refdef.stats.entities_triangles += r_surfacelist[j]->num_triangles;
10445         }
10446
10447         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10448 }
10449
10450 void R_DrawCustomSurface(skinframe_t *skinframe, const matrix4x4_t *texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qboolean writedepth, qboolean prepass)
10451 {
10452         static texture_t texture;
10453         static msurface_t surface;
10454         const msurface_t *surfacelist = &surface;
10455
10456         // fake enough texture and surface state to render this geometry
10457
10458         texture.update_lastrenderframe = -1; // regenerate this texture
10459         texture.basematerialflags = materialflags | MATERIALFLAG_CUSTOMSURFACE | MATERIALFLAG_WALL;
10460         texture.currentskinframe = skinframe;
10461         texture.currenttexmatrix = *texmatrix; // requires MATERIALFLAG_CUSTOMSURFACE
10462         texture.specularscalemod = 1;
10463         texture.specularpowermod = 1;
10464
10465         surface.texture = &texture;
10466         surface.num_triangles = numtriangles;
10467         surface.num_firsttriangle = firsttriangle;
10468         surface.num_vertices = numvertices;
10469         surface.num_firstvertex = firstvertex;
10470
10471         // now render it
10472         rsurface.texture = R_GetCurrentTexture(surface.texture);
10473         rsurface.uselightmaptexture = false;
10474         R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
10475 }
10476
10477 void R_DrawCustomSurface_Texture(texture_t *texture, const matrix4x4_t *texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qboolean writedepth, qboolean prepass)
10478 {
10479         static msurface_t surface;
10480         const msurface_t *surfacelist = &surface;
10481
10482         // fake enough texture and surface state to render this geometry
10483
10484         surface.texture = texture;
10485         surface.num_triangles = numtriangles;
10486         surface.num_firsttriangle = firsttriangle;
10487         surface.num_vertices = numvertices;
10488         surface.num_firstvertex = firstvertex;
10489
10490         // now render it
10491         rsurface.texture = R_GetCurrentTexture(surface.texture);
10492         rsurface.uselightmaptexture = false;
10493         R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
10494 }