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;const char *errorstring = cgGetLastErrorString(&err);if (err){Con_Printf("%s:%i CG error %i: %s\n", __FILE__, __LINE__, err, errorstring);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                         if (r_cg_permutation && r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR
5044                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
5045 #endif
5046                         break;
5047                 case RENDERPATH_GL13:
5048                 case RENDERPATH_GL11:
5049                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
5050                         break;
5051                 }
5052         }
5053 }
5054
5055 void R_ResetViewRendering2D(void)
5056 {
5057         r_viewport_t viewport;
5058         DrawQ_Finish();
5059
5060         // GL is weird because it's bottom to top, r_refdef.view.y is top to bottom
5061         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);
5062         R_SetViewport(&viewport);
5063         GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
5064         GL_Color(1, 1, 1, 1);
5065         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5066         GL_BlendFunc(GL_ONE, GL_ZERO);
5067         GL_AlphaTest(false);
5068         GL_ScissorTest(false);
5069         GL_DepthMask(false);
5070         GL_DepthRange(0, 1);
5071         GL_DepthTest(false);
5072         R_EntityMatrix(&identitymatrix);
5073         R_Mesh_ResetTextureState();
5074         GL_PolygonOffset(0, 0);
5075         qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
5076         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
5077         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
5078         qglStencilMask(~0);CHECKGLERROR
5079         qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
5080         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
5081         GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces
5082 }
5083
5084 void R_ResetViewRendering3D(void)
5085 {
5086         DrawQ_Finish();
5087
5088         R_SetupView(true);
5089         GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5090         GL_Color(1, 1, 1, 1);
5091         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5092         GL_BlendFunc(GL_ONE, GL_ZERO);
5093         GL_AlphaTest(false);
5094         GL_ScissorTest(true);
5095         GL_DepthMask(true);
5096         GL_DepthRange(0, 1);
5097         GL_DepthTest(true);
5098         R_EntityMatrix(&identitymatrix);
5099         R_Mesh_ResetTextureState();
5100         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
5101         qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
5102         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
5103         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
5104         qglStencilMask(~0);CHECKGLERROR
5105         qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
5106         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
5107         GL_CullFace(r_refdef.view.cullface_back);
5108 }
5109
5110 void R_RenderScene(void);
5111 void R_RenderWaterPlanes(void);
5112
5113 static void R_Water_StartFrame(void)
5114 {
5115         int i;
5116         int waterwidth, waterheight, texturewidth, textureheight;
5117         r_waterstate_waterplane_t *p;
5118
5119         if (vid.width > (int)vid.maxtexturesize_2d || vid.height > (int)vid.maxtexturesize_2d)
5120                 return;
5121
5122         switch(vid.renderpath)
5123         {
5124         case RENDERPATH_GL20:
5125         case RENDERPATH_CGGL:
5126                 break;
5127         case RENDERPATH_GL13:
5128         case RENDERPATH_GL11:
5129                 return;
5130         }
5131
5132         // set waterwidth and waterheight to the water resolution that will be
5133         // used (often less than the screen resolution for faster rendering)
5134         waterwidth = (int)bound(1, vid.width * r_water_resolutionmultiplier.value, vid.width);
5135         waterheight = (int)bound(1, vid.height * r_water_resolutionmultiplier.value, vid.height);
5136
5137         // calculate desired texture sizes
5138         // can't use water if the card does not support the texture size
5139         if (!r_water.integer || r_showsurfaces.integer)
5140                 texturewidth = textureheight = waterwidth = waterheight = 0;
5141         else if (vid.support.arb_texture_non_power_of_two)
5142         {
5143                 texturewidth = waterwidth;
5144                 textureheight = waterheight;
5145         }
5146         else
5147         {
5148                 for (texturewidth   = 1;texturewidth   < waterwidth ;texturewidth   *= 2);
5149                 for (textureheight  = 1;textureheight  < waterheight;textureheight  *= 2);
5150         }
5151
5152         // allocate textures as needed
5153         if (r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight)
5154         {
5155                 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
5156                 for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
5157                 {
5158                         if (p->texture_refraction)
5159                                 R_FreeTexture(p->texture_refraction);
5160                         p->texture_refraction = NULL;
5161                         if (p->texture_reflection)
5162                                 R_FreeTexture(p->texture_reflection);
5163                         p->texture_reflection = NULL;
5164                 }
5165                 memset(&r_waterstate, 0, sizeof(r_waterstate));
5166                 r_waterstate.texturewidth = texturewidth;
5167                 r_waterstate.textureheight = textureheight;
5168         }
5169
5170         if (r_waterstate.texturewidth)
5171         {
5172                 r_waterstate.enabled = true;
5173
5174                 // when doing a reduced render (HDR) we want to use a smaller area
5175                 r_waterstate.waterwidth = (int)bound(1, r_refdef.view.width * r_water_resolutionmultiplier.value, r_refdef.view.width);
5176                 r_waterstate.waterheight = (int)bound(1, r_refdef.view.height * r_water_resolutionmultiplier.value, r_refdef.view.height);
5177
5178                 // set up variables that will be used in shader setup
5179                 r_waterstate.screenscale[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
5180                 r_waterstate.screenscale[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
5181                 r_waterstate.screencenter[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
5182                 r_waterstate.screencenter[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
5183         }
5184
5185         r_waterstate.maxwaterplanes = MAX_WATERPLANES;
5186         r_waterstate.numwaterplanes = 0;
5187 }
5188
5189 void R_Water_AddWaterPlane(msurface_t *surface)
5190 {
5191         int triangleindex, planeindex;
5192         const int *e;
5193         vec3_t vert[3];
5194         vec3_t normal;
5195         vec3_t center;
5196         mplane_t plane;
5197         r_waterstate_waterplane_t *p;
5198         texture_t *t = R_GetCurrentTexture(surface->texture);
5199         // just use the first triangle with a valid normal for any decisions
5200         VectorClear(normal);
5201         for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
5202         {
5203                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
5204                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
5205                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
5206                 TriangleNormal(vert[0], vert[1], vert[2], normal);
5207                 if (VectorLength2(normal) >= 0.001)
5208                         break;
5209         }
5210
5211         VectorCopy(normal, plane.normal);
5212         VectorNormalize(plane.normal);
5213         plane.dist = DotProduct(vert[0], plane.normal);
5214         PlaneClassify(&plane);
5215         if (PlaneDiff(r_refdef.view.origin, &plane) < 0)
5216         {
5217                 // skip backfaces (except if nocullface is set)
5218                 if (!(t->currentmaterialflags & MATERIALFLAG_NOCULLFACE))
5219                         return;
5220                 VectorNegate(plane.normal, plane.normal);
5221                 plane.dist *= -1;
5222                 PlaneClassify(&plane);
5223         }
5224
5225
5226         // find a matching plane if there is one
5227         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
5228                 if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
5229                         break;
5230         if (planeindex >= r_waterstate.maxwaterplanes)
5231                 return; // nothing we can do, out of planes
5232
5233         // if this triangle does not fit any known plane rendered this frame, add one
5234         if (planeindex >= r_waterstate.numwaterplanes)
5235         {
5236                 // store the new plane
5237                 r_waterstate.numwaterplanes++;
5238                 p->plane = plane;
5239                 // clear materialflags and pvs
5240                 p->materialflags = 0;
5241                 p->pvsvalid = false;
5242         }
5243         // merge this surface's materialflags into the waterplane
5244         p->materialflags |= t->currentmaterialflags;
5245         // merge this surface's PVS into the waterplane
5246         VectorMAM(0.5f, surface->mins, 0.5f, surface->maxs, center);
5247         if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS
5248          && r_refdef.scene.worldmodel->brush.PointInLeaf && r_refdef.scene.worldmodel->brush.PointInLeaf(r_refdef.scene.worldmodel, center)->clusterindex >= 0)
5249         {
5250                 r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, center, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
5251                 p->pvsvalid = true;
5252         }
5253 }
5254
5255 static void R_Water_ProcessPlanes(void)
5256 {
5257         r_refdef_view_t originalview;
5258         r_refdef_view_t myview;
5259         int planeindex;
5260         r_waterstate_waterplane_t *p;
5261
5262         originalview = r_refdef.view;
5263
5264         // make sure enough textures are allocated
5265         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
5266         {
5267                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
5268                 {
5269                         if (!p->texture_refraction)
5270                                 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);
5271                         if (!p->texture_refraction)
5272                                 goto error;
5273                 }
5274
5275                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
5276                 {
5277                         if (!p->texture_reflection)
5278                                 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);
5279                         if (!p->texture_reflection)
5280                                 goto error;
5281                 }
5282         }
5283
5284         // render views
5285         r_refdef.view = originalview;
5286         r_refdef.view.showdebug = false;
5287         r_refdef.view.width = r_waterstate.waterwidth;
5288         r_refdef.view.height = r_waterstate.waterheight;
5289         r_refdef.view.useclipplane = true;
5290         myview = r_refdef.view;
5291         r_waterstate.renderingscene = true;
5292         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
5293         {
5294                 // render the normal view scene and copy into texture
5295                 // (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)
5296                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
5297                 {
5298                         r_refdef.view = myview;
5299                         r_refdef.view.clipplane = p->plane;
5300                         VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
5301                         r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
5302                         PlaneClassify(&r_refdef.view.clipplane);
5303
5304                         R_ResetViewRendering3D();
5305                         R_ClearScreen(r_refdef.fogenabled);
5306                         R_View_Update();
5307                         R_RenderScene();
5308
5309                         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);
5310                 }
5311
5312                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
5313                 {
5314                         r_refdef.view = myview;
5315                         // render reflected scene and copy into texture
5316                         Matrix4x4_Reflect(&r_refdef.view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
5317                         // update the r_refdef.view.origin because otherwise the sky renders at the wrong location (amongst other problems)
5318                         Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, r_refdef.view.origin);
5319                         r_refdef.view.clipplane = p->plane;
5320                         // reverse the cullface settings for this render
5321                         r_refdef.view.cullface_front = GL_FRONT;
5322                         r_refdef.view.cullface_back = GL_BACK;
5323                         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.num_pvsclusterbytes)
5324                         {
5325                                 r_refdef.view.usecustompvs = true;
5326                                 if (p->pvsvalid)
5327                                         memcpy(r_refdef.viewcache.world_pvsbits, p->pvsbits, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
5328                                 else
5329                                         memset(r_refdef.viewcache.world_pvsbits, 0xFF, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
5330                         }
5331
5332                         R_ResetViewRendering3D();
5333                         R_ClearScreen(r_refdef.fogenabled);
5334                         R_View_Update();
5335                         R_RenderScene();
5336
5337                         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);
5338                 }
5339         }
5340         r_waterstate.renderingscene = false;
5341         r_refdef.view = originalview;
5342         R_ResetViewRendering3D();
5343         R_ClearScreen(r_refdef.fogenabled);
5344         R_View_Update();
5345         return;
5346 error:
5347         r_refdef.view = originalview;
5348         r_waterstate.renderingscene = false;
5349         Cvar_SetValueQuick(&r_water, 0);
5350         Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed!  Turned off r_water.\n");
5351         return;
5352 }
5353
5354 void R_Bloom_StartFrame(void)
5355 {
5356         int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
5357
5358         switch(vid.renderpath)
5359         {
5360         case RENDERPATH_GL20:
5361         case RENDERPATH_CGGL:
5362                 break;
5363         case RENDERPATH_GL13:
5364         case RENDERPATH_GL11:
5365                 return;
5366         }
5367
5368         // set bloomwidth and bloomheight to the bloom resolution that will be
5369         // used (often less than the screen resolution for faster rendering)
5370         r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, vid.height);
5371         r_bloomstate.bloomheight = r_bloomstate.bloomwidth * vid.height / vid.width;
5372         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, vid.height);
5373         r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, (int)vid.maxtexturesize_2d);
5374         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, (int)vid.maxtexturesize_2d);
5375
5376         // calculate desired texture sizes
5377         if (vid.support.arb_texture_non_power_of_two)
5378         {
5379                 screentexturewidth = r_refdef.view.width;
5380                 screentextureheight = r_refdef.view.height;
5381                 bloomtexturewidth = r_bloomstate.bloomwidth;
5382                 bloomtextureheight = r_bloomstate.bloomheight;
5383         }
5384         else
5385         {
5386                 for (screentexturewidth  = 1;screentexturewidth  < vid.width               ;screentexturewidth  *= 2);
5387                 for (screentextureheight = 1;screentextureheight < vid.height              ;screentextureheight *= 2);
5388                 for (bloomtexturewidth   = 1;bloomtexturewidth   < r_bloomstate.bloomwidth ;bloomtexturewidth   *= 2);
5389                 for (bloomtextureheight  = 1;bloomtextureheight  < r_bloomstate.bloomheight;bloomtextureheight  *= 2);
5390         }
5391
5392         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))
5393         {
5394                 Cvar_SetValueQuick(&r_hdr, 0);
5395                 Cvar_SetValueQuick(&r_bloom, 0);
5396                 Cvar_SetValueQuick(&r_motionblur, 0);
5397                 Cvar_SetValueQuick(&r_damageblur, 0);
5398         }
5399
5400         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)))
5401                 screentexturewidth = screentextureheight = 0;
5402         if (!r_hdr.integer && !r_bloom.integer)
5403                 bloomtexturewidth = bloomtextureheight = 0;
5404
5405         // allocate textures as needed
5406         if (r_bloomstate.screentexturewidth != screentexturewidth || r_bloomstate.screentextureheight != screentextureheight)
5407         {
5408                 if (r_bloomstate.texture_screen)
5409                         R_FreeTexture(r_bloomstate.texture_screen);
5410                 r_bloomstate.texture_screen = NULL;
5411                 r_bloomstate.screentexturewidth = screentexturewidth;
5412                 r_bloomstate.screentextureheight = screentextureheight;
5413                 if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight)
5414                         r_bloomstate.texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", r_bloomstate.screentexturewidth, r_bloomstate.screentextureheight, NULL, TEXTYPE_BGRA, TEXF_FORCENEAREST | TEXF_CLAMP, NULL);
5415         }
5416         if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight)
5417         {
5418                 if (r_bloomstate.texture_bloom)
5419                         R_FreeTexture(r_bloomstate.texture_bloom);
5420                 r_bloomstate.texture_bloom = NULL;
5421                 r_bloomstate.bloomtexturewidth = bloomtexturewidth;
5422                 r_bloomstate.bloomtextureheight = bloomtextureheight;
5423                 if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight)
5424                         r_bloomstate.texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", r_bloomstate.bloomtexturewidth, r_bloomstate.bloomtextureheight, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP, NULL);
5425         }
5426
5427         // when doing a reduced render (HDR) we want to use a smaller area
5428         r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, r_refdef.view.height);
5429         r_bloomstate.bloomheight = r_bloomstate.bloomwidth * r_refdef.view.height / r_refdef.view.width;
5430         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_refdef.view.height);
5431         r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, r_bloomstate.bloomtexturewidth);
5432         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_bloomstate.bloomtextureheight);
5433
5434         // set up a texcoord array for the full resolution screen image
5435         // (we have to keep this around to copy back during final render)
5436         r_bloomstate.screentexcoord2f[0] = 0;
5437         r_bloomstate.screentexcoord2f[1] = (float)r_refdef.view.height    / (float)r_bloomstate.screentextureheight;
5438         r_bloomstate.screentexcoord2f[2] = (float)r_refdef.view.width     / (float)r_bloomstate.screentexturewidth;
5439         r_bloomstate.screentexcoord2f[3] = (float)r_refdef.view.height    / (float)r_bloomstate.screentextureheight;
5440         r_bloomstate.screentexcoord2f[4] = (float)r_refdef.view.width     / (float)r_bloomstate.screentexturewidth;
5441         r_bloomstate.screentexcoord2f[5] = 0;
5442         r_bloomstate.screentexcoord2f[6] = 0;
5443         r_bloomstate.screentexcoord2f[7] = 0;
5444
5445         // set up a texcoord array for the reduced resolution bloom image
5446         // (which will be additive blended over the screen image)
5447         r_bloomstate.bloomtexcoord2f[0] = 0;
5448         r_bloomstate.bloomtexcoord2f[1] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
5449         r_bloomstate.bloomtexcoord2f[2] = (float)r_bloomstate.bloomwidth  / (float)r_bloomstate.bloomtexturewidth;
5450         r_bloomstate.bloomtexcoord2f[3] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
5451         r_bloomstate.bloomtexcoord2f[4] = (float)r_bloomstate.bloomwidth  / (float)r_bloomstate.bloomtexturewidth;
5452         r_bloomstate.bloomtexcoord2f[5] = 0;
5453         r_bloomstate.bloomtexcoord2f[6] = 0;
5454         r_bloomstate.bloomtexcoord2f[7] = 0;
5455
5456         if (r_hdr.integer || r_bloom.integer)
5457         {
5458                 r_bloomstate.enabled = true;
5459                 r_bloomstate.hdr = r_hdr.integer != 0;
5460         }
5461
5462         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);
5463 }
5464
5465 void R_Bloom_CopyBloomTexture(float colorscale)
5466 {
5467         r_refdef.stats.bloom++;
5468
5469         // scale down screen texture to the bloom texture size
5470         CHECKGLERROR
5471         R_SetViewport(&r_bloomstate.viewport);
5472         GL_BlendFunc(GL_ONE, GL_ZERO);
5473         GL_Color(colorscale, colorscale, colorscale, 1);
5474         // TODO: optimize with multitexture or GLSL
5475         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
5476         R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
5477         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5478         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5479
5480         // we now have a bloom image in the framebuffer
5481         // copy it into the bloom image texture for later processing
5482         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);
5483         r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
5484 }
5485
5486 void R_Bloom_CopyHDRTexture(void)
5487 {
5488         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);
5489         r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
5490 }
5491
5492 void R_Bloom_MakeTexture(void)
5493 {
5494         int x, range, dir;
5495         float xoffset, yoffset, r, brighten;
5496
5497         r_refdef.stats.bloom++;
5498
5499         R_ResetViewRendering2D();
5500         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5501         R_Mesh_ColorPointer(NULL, 0, 0);
5502
5503         // we have a bloom image in the framebuffer
5504         CHECKGLERROR
5505         R_SetViewport(&r_bloomstate.viewport);
5506
5507         for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
5508         {
5509                 x *= 2;
5510                 r = bound(0, r_bloom_colorexponent.value / x, 1);
5511                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
5512                 GL_Color(r, r, r, 1);
5513                 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
5514                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
5515                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5516                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5517
5518                 // copy the vertically blurred bloom view to a texture
5519                 GL_ActiveTexture(0);
5520                 CHECKGLERROR
5521                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);CHECKGLERROR
5522                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
5523         }
5524
5525         range = r_bloom_blur.integer * r_bloomstate.bloomwidth / 320;
5526         brighten = r_bloom_brighten.value;
5527         if (r_hdr.integer)
5528                 brighten *= r_hdr_range.value;
5529         brighten = sqrt(brighten);
5530         if(range >= 1)
5531                 brighten *= (3 * range) / (2 * range - 1); // compensate for the "dot particle"
5532         R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
5533         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.offsettexcoord2f, 0, 0);
5534
5535         for (dir = 0;dir < 2;dir++)
5536         {
5537                 // blend on at multiple vertical offsets to achieve a vertical blur
5538                 // TODO: do offset blends using GLSL
5539                 // TODO instead of changing the texcoords, change the target positions to prevent artifacts at edges
5540                 GL_BlendFunc(GL_ONE, GL_ZERO);
5541                 for (x = -range;x <= range;x++)
5542                 {
5543                         if (!dir){xoffset = 0;yoffset = x;}
5544                         else {xoffset = x;yoffset = 0;}
5545                         xoffset /= (float)r_bloomstate.bloomtexturewidth;
5546                         yoffset /= (float)r_bloomstate.bloomtextureheight;
5547                         // compute a texcoord array with the specified x and y offset
5548                         r_bloomstate.offsettexcoord2f[0] = xoffset+0;
5549                         r_bloomstate.offsettexcoord2f[1] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
5550                         r_bloomstate.offsettexcoord2f[2] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
5551                         r_bloomstate.offsettexcoord2f[3] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
5552                         r_bloomstate.offsettexcoord2f[4] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
5553                         r_bloomstate.offsettexcoord2f[5] = yoffset+0;
5554                         r_bloomstate.offsettexcoord2f[6] = xoffset+0;
5555                         r_bloomstate.offsettexcoord2f[7] = yoffset+0;
5556                         // this r value looks like a 'dot' particle, fading sharply to
5557                         // black at the edges
5558                         // (probably not realistic but looks good enough)
5559                         //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
5560                         //r = brighten/(range*2+1);
5561                         r = brighten / (range * 2 + 1);
5562                         if(range >= 1)
5563                                 r *= (1 - x*x/(float)(range*range));
5564                         GL_Color(r, r, r, 1);
5565                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5566                         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5567                         GL_BlendFunc(GL_ONE, GL_ONE);
5568                 }
5569
5570                 // copy the vertically blurred bloom view to a texture
5571                 GL_ActiveTexture(0);
5572                 CHECKGLERROR
5573                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);CHECKGLERROR
5574                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
5575         }
5576
5577         // apply subtract last
5578         // (just like it would be in a GLSL shader)
5579         if (r_bloom_colorsubtract.value > 0 && vid.support.ext_blend_subtract)
5580         {
5581                 GL_BlendFunc(GL_ONE, GL_ZERO);
5582                 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
5583                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
5584                 GL_Color(1, 1, 1, 1);
5585                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5586                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5587
5588                 GL_BlendFunc(GL_ONE, GL_ONE);
5589                 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
5590                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
5591                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
5592                 GL_Color(r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 1);
5593                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5594                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5595                 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
5596
5597                 // copy the darkened bloom view to a texture
5598                 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);
5599                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
5600         }
5601 }
5602
5603 void R_HDR_RenderBloomTexture(void)
5604 {
5605         int oldwidth, oldheight;
5606         float oldcolorscale;
5607
5608         oldcolorscale = r_refdef.view.colorscale;
5609         oldwidth = r_refdef.view.width;
5610         oldheight = r_refdef.view.height;
5611         r_refdef.view.width = r_bloomstate.bloomwidth;
5612         r_refdef.view.height = r_bloomstate.bloomheight;
5613
5614         // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer?  it might improve SLI performance.
5615         // TODO: add exposure compensation features
5616         // TODO: add fp16 framebuffer support (using GL_EXT_framebuffer_object)
5617
5618         r_refdef.view.showdebug = false;
5619         r_refdef.view.colorscale *= r_bloom_colorscale.value / bound(1, r_hdr_range.value, 16);
5620
5621         R_ResetViewRendering3D();
5622
5623         R_ClearScreen(r_refdef.fogenabled);
5624         if (r_timereport_active)
5625                 R_TimeReport("HDRclear");
5626
5627         R_View_Update();
5628         if (r_timereport_active)
5629                 R_TimeReport("visibility");
5630
5631         // only do secondary renders with HDR if r_hdr is 2 or higher
5632         r_waterstate.numwaterplanes = 0;
5633         if (r_waterstate.enabled && r_hdr.integer >= 2)
5634                 R_RenderWaterPlanes();
5635
5636         r_refdef.view.showdebug = true;
5637         R_RenderScene();
5638         r_waterstate.numwaterplanes = 0;
5639
5640         R_ResetViewRendering2D();
5641
5642         R_Bloom_CopyHDRTexture();
5643         R_Bloom_MakeTexture();
5644
5645         // restore the view settings
5646         r_refdef.view.width = oldwidth;
5647         r_refdef.view.height = oldheight;
5648         r_refdef.view.colorscale = oldcolorscale;
5649         r_frame++; // used only by R_GetCurrentTexture
5650
5651         R_ResetViewRendering3D();
5652
5653         R_ClearScreen(r_refdef.fogenabled);
5654         if (r_timereport_active)
5655                 R_TimeReport("viewclear");
5656 }
5657
5658 static void R_BlendView(void)
5659 {
5660         unsigned int permutation;
5661         float uservecs[4][4];
5662
5663         switch (vid.renderpath)
5664         {
5665         case RENDERPATH_GL20:
5666         case RENDERPATH_CGGL:
5667                 permutation =
5668                           (r_bloomstate.texture_bloom ? SHADERPERMUTATION_BLOOM : 0)
5669                         | (r_refdef.viewblend[3] > 0 ? SHADERPERMUTATION_VIEWTINT : 0)
5670                         | ((v_glslgamma.value && !vid_gammatables_trivial) ? SHADERPERMUTATION_GAMMARAMPS : 0)
5671                         | (r_glsl_postprocess.integer ? SHADERPERMUTATION_POSTPROCESSING : 0)
5672                         | ((!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) ? SHADERPERMUTATION_SATURATION : 0);
5673
5674                 if (r_bloomstate.texture_screen)
5675                 {
5676                         // make sure the buffer is available
5677                         if (r_bloom_blur.value < 1) { Cvar_SetValueQuick(&r_bloom_blur, 1); }
5678
5679                         R_ResetViewRendering2D();
5680                         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5681                         R_Mesh_ColorPointer(NULL, 0, 0);
5682
5683                         if(!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0))
5684                         {
5685                                 // declare variables
5686                                 float speed;
5687                                 static float avgspeed;
5688
5689                                 speed = VectorLength(cl.movement_velocity);
5690
5691                                 cl.motionbluralpha = bound(0, (cl.time - cl.oldtime) / max(0.001, r_motionblur_vcoeff.value), 1);
5692                                 avgspeed = avgspeed * (1 - cl.motionbluralpha) + speed * cl.motionbluralpha;
5693
5694                                 speed = (avgspeed - r_motionblur_vmin.value) / max(1, r_motionblur_vmax.value - r_motionblur_vmin.value);
5695                                 speed = bound(0, speed, 1);
5696                                 speed = speed * (1 - r_motionblur_bmin.value) + r_motionblur_bmin.value;
5697
5698                                 // calculate values into a standard alpha
5699                                 cl.motionbluralpha = 1 - exp(-
5700                                                 (
5701                                                  (r_motionblur.value * speed / 80)
5702                                                  +
5703                                                  (r_damageblur.value * (cl.cshifts[CSHIFT_DAMAGE].percent / 1600))
5704                                                 )
5705                                                 /
5706                                                 max(0.0001, cl.time - cl.oldtime) // fps independent
5707                                            );
5708
5709                                 cl.motionbluralpha *= lhrandom(1 - r_motionblur_randomize.value, 1 + r_motionblur_randomize.value);
5710                                 cl.motionbluralpha = bound(0, cl.motionbluralpha, r_motionblur_maxblur.value);
5711                                 // apply the blur
5712                                 if (cl.motionbluralpha > 0)
5713                                 {
5714                                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5715                                         GL_Color(1, 1, 1, cl.motionbluralpha);
5716                                         R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
5717                                         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
5718                                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5719                                         r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
5720                                 }
5721                         }
5722
5723                         // copy view into the screen texture
5724                         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);
5725                         r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
5726                 }
5727                 else if (!r_bloomstate.texture_bloom)
5728                 {
5729                         // we may still have to do view tint...
5730                         if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
5731                         {
5732                                 // apply a color tint to the whole view
5733                                 R_ResetViewRendering2D();
5734                                 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5735                                 R_Mesh_ColorPointer(NULL, 0, 0);
5736                                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
5737                                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5738                                 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
5739                                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5740                         }
5741                         break; // no screen processing, no bloom, skip it
5742                 }
5743
5744                 if (r_bloomstate.texture_bloom && !r_bloomstate.hdr)
5745                 {
5746                         // render simple bloom effect
5747                         // copy the screen and shrink it and darken it for the bloom process
5748                         R_Bloom_CopyBloomTexture(r_bloom_colorscale.value);
5749                         // make the bloom texture
5750                         R_Bloom_MakeTexture();
5751                 }
5752
5753 #if _MSC_VER >= 1400
5754 #define sscanf sscanf_s
5755 #endif
5756                 memset(uservecs, 0, sizeof(uservecs));
5757                 sscanf(r_glsl_postprocess_uservec1.string, "%f %f %f %f", &uservecs[0][0], &uservecs[0][1], &uservecs[0][2], &uservecs[0][3]);
5758                 sscanf(r_glsl_postprocess_uservec2.string, "%f %f %f %f", &uservecs[1][0], &uservecs[1][1], &uservecs[1][2], &uservecs[1][3]);
5759                 sscanf(r_glsl_postprocess_uservec3.string, "%f %f %f %f", &uservecs[2][0], &uservecs[2][1], &uservecs[2][2], &uservecs[2][3]);
5760                 sscanf(r_glsl_postprocess_uservec4.string, "%f %f %f %f", &uservecs[3][0], &uservecs[3][1], &uservecs[3][2], &uservecs[3][3]);
5761
5762                 R_ResetViewRendering2D();
5763                 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5764                 R_Mesh_ColorPointer(NULL, 0, 0);
5765                 GL_Color(1, 1, 1, 1);
5766                 GL_BlendFunc(GL_ONE, GL_ZERO);
5767                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
5768                 R_Mesh_TexCoordPointer(1, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
5769
5770                 switch(vid.renderpath)
5771                 {
5772                 case RENDERPATH_GL20:
5773                         R_SetupShader_SetPermutationGLSL(SHADERMODE_POSTPROCESS, permutation);
5774                         if (r_glsl_permutation->loc_Texture_First      >= 0) R_Mesh_TexBind(GL20TU_FIRST     , R_GetTexture(r_bloomstate.texture_screen));
5775                         if (r_glsl_permutation->loc_Texture_Second     >= 0) R_Mesh_TexBind(GL20TU_SECOND    , R_GetTexture(r_bloomstate.texture_bloom ));
5776                         if (r_glsl_permutation->loc_Texture_GammaRamps >= 0) R_Mesh_TexBind(GL20TU_GAMMARAMPS, R_GetTexture(r_texture_gammaramps       ));
5777                         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]);
5778                         if (r_glsl_permutation->loc_ClientTime         >= 0) qglUniform1fARB(r_glsl_permutation->loc_ClientTime        , cl.time);
5779                         if (r_glsl_permutation->loc_PixelSize          >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelSize         , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);
5780                         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]);
5781                         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]);
5782                         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]);
5783                         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]);
5784                         if (r_glsl_permutation->loc_Saturation         >= 0) qglUniform1fARB(r_glsl_permutation->loc_Saturation        , r_glsl_saturation.value);
5785                         break;
5786                 case RENDERPATH_CGGL:
5787 #ifdef SUPPORTCG
5788                         R_SetupShader_SetPermutationCG(SHADERMODE_POSTPROCESS, permutation);
5789                         if (r_cg_permutation->fp_Texture_First     ) CG_BindTexture(r_cg_permutation->fp_Texture_First     , R_GetTexture(r_bloomstate.texture_screen));CHECKCGERROR
5790                         if (r_cg_permutation->fp_Texture_Second    ) CG_BindTexture(r_cg_permutation->fp_Texture_Second    , R_GetTexture(r_bloomstate.texture_bloom ));CHECKCGERROR
5791                         if (r_cg_permutation->fp_Texture_GammaRamps) CG_BindTexture(r_cg_permutation->fp_Texture_GammaRamps, R_GetTexture(r_texture_gammaramps       ));CHECKCGERROR
5792                         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
5793                         if (r_cg_permutation->fp_ClientTime        ) cgGLSetParameter1f(     r_cg_permutation->fp_ClientTime        , cl.time);CHECKCGERROR
5794                         if (r_cg_permutation->fp_PixelSize         ) cgGLSetParameter2f(     r_cg_permutation->fp_PixelSize         , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);CHECKCGERROR
5795                         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
5796                         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
5797                         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
5798                         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
5799                         if (r_cg_permutation->fp_Saturation        ) cgGLSetParameter1f(     r_cg_permutation->fp_Saturation        , r_glsl_saturation.value);CHECKCGERROR
5800 #endif
5801                         break;
5802                 default:
5803                         break;
5804                 }
5805                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5806                 r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
5807                 break;
5808         case RENDERPATH_GL13:
5809         case RENDERPATH_GL11:
5810                 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
5811                 {
5812                         // apply a color tint to the whole view
5813                         R_ResetViewRendering2D();
5814                         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5815                         R_Mesh_ColorPointer(NULL, 0, 0);
5816                         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
5817                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5818                         GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
5819                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5820                 }
5821                 break;
5822         }
5823 }
5824
5825 matrix4x4_t r_waterscrollmatrix;
5826
5827 void R_UpdateFogColor(void) // needs to be called before HDR subrender too, as that changes colorscale!
5828 {
5829         if (r_refdef.fog_density)
5830         {
5831                 r_refdef.fogcolor[0] = r_refdef.fog_red;
5832                 r_refdef.fogcolor[1] = r_refdef.fog_green;
5833                 r_refdef.fogcolor[2] = r_refdef.fog_blue;
5834
5835                 Vector4Set(r_refdef.fogplane, 0, 0, 1, -r_refdef.fog_height);
5836                 r_refdef.fogplaneviewdist = DotProduct(r_refdef.fogplane, r_refdef.view.origin) + r_refdef.fogplane[3];
5837                 r_refdef.fogplaneviewabove = r_refdef.fogplaneviewdist >= 0;
5838                 r_refdef.fogheightfade = -0.5f/max(0.125f, r_refdef.fog_fadedepth);
5839
5840                 {
5841                         vec3_t fogvec;
5842                         VectorCopy(r_refdef.fogcolor, fogvec);
5843                         //   color.rgb *= ContrastBoost * SceneBrightness;
5844                         VectorScale(fogvec, r_refdef.view.colorscale, fogvec);
5845                         r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
5846                         r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
5847                         r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
5848                 }
5849         }
5850 }
5851
5852 void R_UpdateVariables(void)
5853 {
5854         R_Textures_Frame();
5855
5856         r_refdef.scene.ambient = r_ambient.value * (1.0f / 64.0f);
5857
5858         r_refdef.farclip = r_farclip_base.value;
5859         if (r_refdef.scene.worldmodel)
5860                 r_refdef.farclip += r_refdef.scene.worldmodel->radius * r_farclip_world.value * 2;
5861         r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
5862
5863         if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
5864                 Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
5865         r_refdef.polygonfactor = 0;
5866         r_refdef.polygonoffset = 0;
5867         r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
5868         r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
5869
5870         r_refdef.scene.rtworld = r_shadow_realtime_world.integer != 0;
5871         r_refdef.scene.rtworldshadows = r_shadow_realtime_world_shadows.integer && vid.stencil;
5872         r_refdef.scene.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer;
5873         r_refdef.scene.rtdlightshadows = r_refdef.scene.rtdlight && r_shadow_realtime_dlight_shadows.integer && vid.stencil;
5874         r_refdef.lightmapintensity = r_refdef.scene.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
5875         if (r_showsurfaces.integer)
5876         {
5877                 r_refdef.scene.rtworld = false;
5878                 r_refdef.scene.rtworldshadows = false;
5879                 r_refdef.scene.rtdlight = false;
5880                 r_refdef.scene.rtdlightshadows = false;
5881                 r_refdef.lightmapintensity = 0;
5882         }
5883
5884         if (gamemode == GAME_NEHAHRA)
5885         {
5886                 if (gl_fogenable.integer)
5887                 {
5888                         r_refdef.oldgl_fogenable = true;
5889                         r_refdef.fog_density = gl_fogdensity.value;
5890                         r_refdef.fog_red = gl_fogred.value;
5891                         r_refdef.fog_green = gl_foggreen.value;
5892                         r_refdef.fog_blue = gl_fogblue.value;
5893                         r_refdef.fog_alpha = 1;
5894                         r_refdef.fog_start = 0;
5895                         r_refdef.fog_end = gl_skyclip.value;
5896                         r_refdef.fog_height = 1<<30;
5897                         r_refdef.fog_fadedepth = 128;
5898                 }
5899                 else if (r_refdef.oldgl_fogenable)
5900                 {
5901                         r_refdef.oldgl_fogenable = false;
5902                         r_refdef.fog_density = 0;
5903                         r_refdef.fog_red = 0;
5904                         r_refdef.fog_green = 0;
5905                         r_refdef.fog_blue = 0;
5906                         r_refdef.fog_alpha = 0;
5907                         r_refdef.fog_start = 0;
5908                         r_refdef.fog_end = 0;
5909                         r_refdef.fog_height = 1<<30;
5910                         r_refdef.fog_fadedepth = 128;
5911                 }
5912         }
5913
5914         r_refdef.fog_alpha = bound(0, r_refdef.fog_alpha, 1);
5915         r_refdef.fog_start = max(0, r_refdef.fog_start);
5916         r_refdef.fog_end = max(r_refdef.fog_start + 0.01, r_refdef.fog_end);
5917
5918         // R_UpdateFogColor(); // why? R_RenderScene does it anyway
5919
5920         if (r_refdef.fog_density && r_drawfog.integer)
5921         {
5922                 r_refdef.fogenabled = true;
5923                 // this is the point where the fog reaches 0.9986 alpha, which we
5924                 // consider a good enough cutoff point for the texture
5925                 // (0.9986 * 256 == 255.6)
5926                 if (r_fog_exp2.integer)
5927                         r_refdef.fogrange = 32 / (r_refdef.fog_density * r_refdef.fog_density) + r_refdef.fog_start;
5928                 else
5929                         r_refdef.fogrange = 2048 / r_refdef.fog_density + r_refdef.fog_start;
5930                 r_refdef.fogrange = bound(r_refdef.fog_start, r_refdef.fogrange, r_refdef.fog_end);
5931                 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
5932                 r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
5933                 // fog color was already set
5934                 // update the fog texture
5935                 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)
5936                         R_BuildFogTexture();
5937         }
5938         else
5939                 r_refdef.fogenabled = false;
5940
5941         switch(vid.renderpath)
5942         {
5943         case RENDERPATH_GL20:
5944         case RENDERPATH_CGGL:
5945                 if(v_glslgamma.integer && !vid_gammatables_trivial)
5946                 {
5947                         if(!r_texture_gammaramps || vid_gammatables_serial != r_texture_gammaramps_serial)
5948                         {
5949                                 // build GLSL gamma texture
5950 #define RAMPWIDTH 256
5951                                 unsigned short ramp[RAMPWIDTH * 3];
5952                                 unsigned char rampbgr[RAMPWIDTH][4];
5953                                 int i;
5954
5955                                 r_texture_gammaramps_serial = vid_gammatables_serial;
5956
5957                                 VID_BuildGammaTables(&ramp[0], RAMPWIDTH);
5958                                 for(i = 0; i < RAMPWIDTH; ++i)
5959                                 {
5960                                         rampbgr[i][0] = (unsigned char) (ramp[i + 2 * RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
5961                                         rampbgr[i][1] = (unsigned char) (ramp[i + RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
5962                                         rampbgr[i][2] = (unsigned char) (ramp[i] * 255.0 / 65535.0 + 0.5);
5963                                         rampbgr[i][3] = 0;
5964                                 }
5965                                 if (r_texture_gammaramps)
5966                                 {
5967                                         R_UpdateTexture(r_texture_gammaramps, &rampbgr[0][0], 0, 0, RAMPWIDTH, 1);
5968                                 }
5969                                 else
5970                                 {
5971                                         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);
5972                                 }
5973                         }
5974                 }
5975                 else
5976                 {
5977                         // remove GLSL gamma texture
5978                 }
5979                 break;
5980         case RENDERPATH_GL13:
5981         case RENDERPATH_GL11:
5982                 break;
5983         }
5984 }
5985
5986 static r_refdef_scene_type_t r_currentscenetype = RST_CLIENT;
5987 static r_refdef_scene_t r_scenes_store[ RST_COUNT ];
5988 /*
5989 ================
5990 R_SelectScene
5991 ================
5992 */
5993 void R_SelectScene( r_refdef_scene_type_t scenetype ) {
5994         if( scenetype != r_currentscenetype ) {
5995                 // store the old scenetype
5996                 r_scenes_store[ r_currentscenetype ] = r_refdef.scene;
5997                 r_currentscenetype = scenetype;
5998                 // move in the new scene
5999                 r_refdef.scene = r_scenes_store[ r_currentscenetype ];
6000         }
6001 }
6002
6003 /*
6004 ================
6005 R_GetScenePointer
6006 ================
6007 */
6008 r_refdef_scene_t * R_GetScenePointer( r_refdef_scene_type_t scenetype )
6009 {
6010         // of course, we could also add a qboolean that provides a lock state and a ReleaseScenePointer function..
6011         if( scenetype == r_currentscenetype ) {
6012                 return &r_refdef.scene;
6013         } else {
6014                 return &r_scenes_store[ scenetype ];
6015         }
6016 }
6017
6018 /*
6019 ================
6020 R_RenderView
6021 ================
6022 */
6023 void R_RenderView(void)
6024 {
6025         if (r_timereport_active)
6026                 R_TimeReport("start");
6027         r_frame++; // used only by R_GetCurrentTexture
6028         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
6029
6030         if (!r_drawentities.integer)
6031                 r_refdef.scene.numentities = 0;
6032
6033         R_AnimCache_ClearCache();
6034         R_FrameData_NewFrame();
6035
6036         if (r_refdef.view.isoverlay)
6037         {
6038                 // TODO: FIXME: move this into its own backend function maybe? [2/5/2008 Andreas]
6039                 GL_Clear( GL_DEPTH_BUFFER_BIT );
6040                 R_TimeReport("depthclear");
6041
6042                 r_refdef.view.showdebug = false;
6043
6044                 r_waterstate.enabled = false;
6045                 r_waterstate.numwaterplanes = 0;
6046
6047                 R_RenderScene();
6048
6049                 CHECKGLERROR
6050                 return;
6051         }
6052
6053         if (!r_refdef.scene.entities || r_refdef.view.width * r_refdef.view.height == 0 || !r_renderview.integer/* || !r_refdef.scene.worldmodel*/)
6054                 return; //Host_Error ("R_RenderView: NULL worldmodel");
6055
6056         r_refdef.view.colorscale = r_hdr_scenebrightness.value;
6057
6058         // break apart the view matrix into vectors for various purposes
6059         // it is important that this occurs outside the RenderScene function because that can be called from reflection renders, where the vectors come out wrong
6060         // however the r_refdef.view.origin IS updated in RenderScene intentionally - otherwise the sky renders at the wrong origin, etc
6061         Matrix4x4_ToVectors(&r_refdef.view.matrix, r_refdef.view.forward, r_refdef.view.left, r_refdef.view.up, r_refdef.view.origin);
6062         VectorNegate(r_refdef.view.left, r_refdef.view.right);
6063         // make an inverted copy of the view matrix for tracking sprites
6064         Matrix4x4_Invert_Simple(&r_refdef.view.inverse_matrix, &r_refdef.view.matrix);
6065
6066         R_Shadow_UpdateWorldLightSelection();
6067
6068         R_Bloom_StartFrame();
6069         R_Water_StartFrame();
6070
6071         CHECKGLERROR
6072         if (r_timereport_active)
6073                 R_TimeReport("viewsetup");
6074
6075         R_ResetViewRendering3D();
6076
6077         if (r_refdef.view.clear || r_refdef.fogenabled)
6078         {
6079                 R_ClearScreen(r_refdef.fogenabled);
6080                 if (r_timereport_active)
6081                         R_TimeReport("viewclear");
6082         }
6083         r_refdef.view.clear = true;
6084
6085         // this produces a bloom texture to be used in R_BlendView() later
6086         if (r_hdr.integer && r_bloomstate.bloomwidth)
6087                 R_HDR_RenderBloomTexture();
6088
6089         r_refdef.view.showdebug = true;
6090
6091         R_View_Update();
6092         if (r_timereport_active)
6093                 R_TimeReport("visibility");
6094
6095         r_waterstate.numwaterplanes = 0;
6096         if (r_waterstate.enabled)
6097                 R_RenderWaterPlanes();
6098
6099         R_RenderScene();
6100         r_waterstate.numwaterplanes = 0;
6101
6102         R_BlendView();
6103         if (r_timereport_active)
6104                 R_TimeReport("blendview");
6105
6106         GL_Scissor(0, 0, vid.width, vid.height);
6107         GL_ScissorTest(false);
6108         CHECKGLERROR
6109 }
6110
6111 void R_RenderWaterPlanes(void)
6112 {
6113         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawAddWaterPlanes)
6114         {
6115                 r_refdef.scene.worldmodel->DrawAddWaterPlanes(r_refdef.scene.worldentity);
6116                 if (r_timereport_active)
6117                         R_TimeReport("waterworld");
6118         }
6119
6120         // don't let sound skip if going slow
6121         if (r_refdef.scene.extraupdate)
6122                 S_ExtraUpdate ();
6123
6124         R_DrawModelsAddWaterPlanes();
6125         if (r_timereport_active)
6126                 R_TimeReport("watermodels");
6127
6128         if (r_waterstate.numwaterplanes)
6129         {
6130                 R_Water_ProcessPlanes();
6131                 if (r_timereport_active)
6132                         R_TimeReport("waterscenes");
6133         }
6134 }
6135
6136 extern void R_DrawLightningBeams (void);
6137 extern void VM_CL_AddPolygonsToMeshQueue (void);
6138 extern void R_DrawPortals (void);
6139 extern cvar_t cl_locs_show;
6140 static void R_DrawLocs(void);
6141 static void R_DrawEntityBBoxes(void);
6142 static void R_DrawModelDecals(void);
6143 extern cvar_t cl_decals_newsystem;
6144 extern qboolean r_shadow_usingdeferredprepass;
6145 void R_RenderScene(void)
6146 {
6147         r_refdef.stats.renders++;
6148
6149         R_UpdateFogColor();
6150
6151         // don't let sound skip if going slow
6152         if (r_refdef.scene.extraupdate)
6153                 S_ExtraUpdate ();
6154
6155         R_MeshQueue_BeginScene();
6156
6157         R_SkyStartFrame();
6158
6159         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);
6160
6161         if (cl.csqc_vidvars.drawworld)
6162         {
6163                 // don't let sound skip if going slow
6164                 if (r_refdef.scene.extraupdate)
6165                         S_ExtraUpdate ();
6166
6167                 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawSky)
6168                 {
6169                         r_refdef.scene.worldmodel->DrawSky(r_refdef.scene.worldentity);
6170                         if (r_timereport_active)
6171                                 R_TimeReport("worldsky");
6172                 }
6173
6174                 if (R_DrawBrushModelsSky() && r_timereport_active)
6175                         R_TimeReport("bmodelsky");
6176
6177                 if (skyrendermasked && skyrenderlater)
6178                 {
6179                         // we have to force off the water clipping plane while rendering sky
6180                         R_SetupView(false);
6181                         R_Sky();
6182                         R_SetupView(true);
6183                         if (r_timereport_active)
6184                                 R_TimeReport("sky");
6185                 }
6186         }
6187
6188         R_AnimCache_CacheVisibleEntities();
6189         if (r_timereport_active)
6190                 R_TimeReport("animation");
6191
6192         R_Shadow_PrepareLights();
6193         if (r_timereport_active)
6194                 R_TimeReport("preparelights");
6195
6196         if (r_shadow_usingdeferredprepass)
6197                 R_Shadow_DrawPrepass();
6198
6199         if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawDepth)
6200         {
6201                 r_refdef.scene.worldmodel->DrawDepth(r_refdef.scene.worldentity);
6202                 if (r_timereport_active)
6203                         R_TimeReport("worlddepth");
6204         }
6205         if (r_depthfirst.integer >= 2)
6206         {
6207                 R_DrawModelsDepth();
6208                 if (r_timereport_active)
6209                         R_TimeReport("modeldepth");
6210         }
6211
6212         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->Draw)
6213         {
6214                 r_refdef.scene.worldmodel->Draw(r_refdef.scene.worldentity);
6215                 if (r_timereport_active)
6216                         R_TimeReport("world");
6217         }
6218
6219         // don't let sound skip if going slow
6220         if (r_refdef.scene.extraupdate)
6221                 S_ExtraUpdate ();
6222
6223         R_DrawModels();
6224         if (r_timereport_active)
6225                 R_TimeReport("models");
6226
6227         // don't let sound skip if going slow
6228         if (r_refdef.scene.extraupdate)
6229                 S_ExtraUpdate ();
6230
6231         if (r_shadows.integer > 0 && !r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
6232         {
6233                 R_DrawModelShadows();
6234                 R_ResetViewRendering3D();
6235                 // don't let sound skip if going slow
6236                 if (r_refdef.scene.extraupdate)
6237                         S_ExtraUpdate ();
6238         }
6239
6240         if (!r_shadow_usingdeferredprepass)
6241         {
6242                 R_Shadow_DrawLights();
6243                 if (r_timereport_active)
6244                         R_TimeReport("rtlights");
6245         }
6246
6247         // don't let sound skip if going slow
6248         if (r_refdef.scene.extraupdate)
6249                 S_ExtraUpdate ();
6250
6251         if (r_shadows.integer > 0 && r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
6252         {
6253                 R_DrawModelShadows();
6254                 R_ResetViewRendering3D();
6255                 // don't let sound skip if going slow
6256                 if (r_refdef.scene.extraupdate)
6257                         S_ExtraUpdate ();
6258         }
6259
6260         if (cl.csqc_vidvars.drawworld)
6261         {
6262                 if (cl_decals_newsystem.integer)
6263                 {
6264                         R_DrawModelDecals();
6265                         if (r_timereport_active)
6266                                 R_TimeReport("modeldecals");
6267                 }
6268                 else
6269                 {
6270                         R_DrawDecals();
6271                         if (r_timereport_active)
6272                                 R_TimeReport("decals");
6273                 }
6274
6275                 R_DrawParticles();
6276                 if (r_timereport_active)
6277                         R_TimeReport("particles");
6278
6279                 R_DrawExplosions();
6280                 if (r_timereport_active)
6281                         R_TimeReport("explosions");
6282
6283                 R_DrawLightningBeams();
6284                 if (r_timereport_active)
6285                         R_TimeReport("lightning");
6286         }
6287
6288         VM_CL_AddPolygonsToMeshQueue();
6289
6290         if (r_refdef.view.showdebug)
6291         {
6292                 if (cl_locs_show.integer)
6293                 {
6294                         R_DrawLocs();
6295                         if (r_timereport_active)
6296                                 R_TimeReport("showlocs");
6297                 }
6298
6299                 if (r_drawportals.integer)
6300                 {
6301                         R_DrawPortals();
6302                         if (r_timereport_active)
6303                                 R_TimeReport("portals");
6304                 }
6305
6306                 if (r_showbboxes.value > 0)
6307                 {
6308                         R_DrawEntityBBoxes();
6309                         if (r_timereport_active)
6310                                 R_TimeReport("bboxes");
6311                 }
6312         }
6313
6314         R_MeshQueue_RenderTransparent();
6315         if (r_timereport_active)
6316                 R_TimeReport("drawtrans");
6317
6318         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))
6319         {
6320                 r_refdef.scene.worldmodel->DrawDebug(r_refdef.scene.worldentity);
6321                 if (r_timereport_active)
6322                         R_TimeReport("worlddebug");
6323                 R_DrawModelsDebug();
6324                 if (r_timereport_active)
6325                         R_TimeReport("modeldebug");
6326         }
6327
6328         if (cl.csqc_vidvars.drawworld)
6329         {
6330                 R_Shadow_DrawCoronas();
6331                 if (r_timereport_active)
6332                         R_TimeReport("coronas");
6333         }
6334
6335         // don't let sound skip if going slow
6336         if (r_refdef.scene.extraupdate)
6337                 S_ExtraUpdate ();
6338
6339         R_ResetViewRendering2D();
6340 }
6341
6342 static const unsigned short bboxelements[36] =
6343 {
6344         5, 1, 3, 5, 3, 7,
6345         6, 2, 0, 6, 0, 4,
6346         7, 3, 2, 7, 2, 6,
6347         4, 0, 1, 4, 1, 5,
6348         4, 5, 7, 4, 7, 6,
6349         1, 0, 2, 1, 2, 3,
6350 };
6351
6352 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
6353 {
6354         int i;
6355         float *v, *c, f1, f2, vertex3f[8*3], color4f[8*4];
6356
6357         RSurf_ActiveWorldEntity();
6358
6359         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6360         GL_DepthMask(false);
6361         GL_DepthRange(0, 1);
6362         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
6363         R_Mesh_ResetTextureState();
6364
6365         vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; //
6366         vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
6367         vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
6368         vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
6369         vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
6370         vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
6371         vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
6372         vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
6373         R_FillColors(color4f, 8, cr, cg, cb, ca);
6374         if (r_refdef.fogenabled)
6375         {
6376                 for (i = 0, v = vertex3f, c = color4f;i < 8;i++, v += 3, c += 4)
6377                 {
6378                         f1 = RSurf_FogVertex(v);
6379                         f2 = 1 - f1;
6380                         c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
6381                         c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
6382                         c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
6383                 }
6384         }
6385         R_Mesh_VertexPointer(vertex3f, 0, 0);
6386         R_Mesh_ColorPointer(color4f, 0, 0);
6387         R_Mesh_ResetTextureState();
6388         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
6389         R_Mesh_Draw(0, 8, 0, 12, NULL, bboxelements, 0, 0);
6390 }
6391
6392 static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
6393 {
6394         int i;
6395         float color[4];
6396         prvm_edict_t *edict;
6397         prvm_prog_t *prog_save = prog;
6398
6399         // this function draws bounding boxes of server entities
6400         if (!sv.active)
6401                 return;
6402
6403         GL_CullFace(GL_NONE);
6404         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
6405
6406         prog = 0;
6407         SV_VM_Begin();
6408         for (i = 0;i < numsurfaces;i++)
6409         {
6410                 edict = PRVM_EDICT_NUM(surfacelist[i]);
6411                 switch ((int)edict->fields.server->solid)
6412                 {
6413                         case SOLID_NOT:      Vector4Set(color, 1, 1, 1, 0.05);break;
6414                         case SOLID_TRIGGER:  Vector4Set(color, 1, 0, 1, 0.10);break;
6415                         case SOLID_BBOX:     Vector4Set(color, 0, 1, 0, 0.10);break;
6416                         case SOLID_SLIDEBOX: Vector4Set(color, 1, 0, 0, 0.10);break;
6417                         case SOLID_BSP:      Vector4Set(color, 0, 0, 1, 0.05);break;
6418                         default:             Vector4Set(color, 0, 0, 0, 0.50);break;
6419                 }
6420                 color[3] *= r_showbboxes.value;
6421                 color[3] = bound(0, color[3], 1);
6422                 GL_DepthTest(!r_showdisabledepthtest.integer);
6423                 GL_CullFace(r_refdef.view.cullface_front);
6424                 R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
6425         }
6426         SV_VM_End();
6427         prog = prog_save;
6428 }
6429
6430 static void R_DrawEntityBBoxes(void)
6431 {
6432         int i;
6433         prvm_edict_t *edict;
6434         vec3_t center;
6435         prvm_prog_t *prog_save = prog;
6436
6437         // this function draws bounding boxes of server entities
6438         if (!sv.active)
6439                 return;
6440
6441         prog = 0;
6442         SV_VM_Begin();
6443         for (i = 0;i < prog->num_edicts;i++)
6444         {
6445                 edict = PRVM_EDICT_NUM(i);
6446                 if (edict->priv.server->free)
6447                         continue;
6448                 // exclude the following for now, as they don't live in world coordinate space and can't be solid:
6449                 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.tag_entity)->edict != 0)
6450                         continue;
6451                 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.viewmodelforclient)->edict != 0)
6452                         continue;
6453                 VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
6454                 R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
6455         }
6456         SV_VM_End();
6457         prog = prog_save;
6458 }
6459
6460 static const int nomodelelement3i[24] =
6461 {
6462         5, 2, 0,
6463         5, 1, 2,
6464         5, 0, 3,
6465         5, 3, 1,
6466         0, 2, 4,
6467         2, 1, 4,
6468         3, 0, 4,
6469         1, 3, 4
6470 };
6471
6472 static const unsigned short nomodelelement3s[24] =
6473 {
6474         5, 2, 0,
6475         5, 1, 2,
6476         5, 0, 3,
6477         5, 3, 1,
6478         0, 2, 4,
6479         2, 1, 4,
6480         3, 0, 4,
6481         1, 3, 4
6482 };
6483
6484 static const float nomodelvertex3f[6*3] =
6485 {
6486         -16,   0,   0,
6487          16,   0,   0,
6488           0, -16,   0,
6489           0,  16,   0,
6490           0,   0, -16,
6491           0,   0,  16
6492 };
6493
6494 static const float nomodelcolor4f[6*4] =
6495 {
6496         0.0f, 0.0f, 0.5f, 1.0f,
6497         0.0f, 0.0f, 0.5f, 1.0f,
6498         0.0f, 0.5f, 0.0f, 1.0f,
6499         0.0f, 0.5f, 0.0f, 1.0f,
6500         0.5f, 0.0f, 0.0f, 1.0f,
6501         0.5f, 0.0f, 0.0f, 1.0f
6502 };
6503
6504 void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
6505 {
6506         int i;
6507         float f1, f2, *c;
6508         float color4f[6*4];
6509
6510         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);
6511
6512         // this is only called once per entity so numsurfaces is always 1, and
6513         // surfacelist is always {0}, so this code does not handle batches
6514
6515         if (rsurface.ent_flags & RENDER_ADDITIVE)
6516         {
6517                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
6518                 GL_DepthMask(false);
6519         }
6520         else if (rsurface.colormod[3] < 1)
6521         {
6522                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6523                 GL_DepthMask(false);
6524         }
6525         else
6526         {
6527                 GL_BlendFunc(GL_ONE, GL_ZERO);
6528                 GL_DepthMask(true);
6529         }
6530         GL_DepthRange(0, (rsurface.ent_flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
6531         GL_PolygonOffset(rsurface.basepolygonfactor, rsurface.basepolygonoffset);
6532         GL_DepthTest(!(rsurface.ent_flags & RENDER_NODEPTHTEST));
6533         GL_CullFace((rsurface.ent_flags & RENDER_DOUBLESIDED) ? GL_NONE : r_refdef.view.cullface_back);
6534         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
6535         R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
6536         memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
6537         R_Mesh_ColorPointer(color4f, 0, 0);
6538         for (i = 0, c = color4f;i < 6;i++, c += 4)
6539         {
6540                 c[0] *= rsurface.colormod[0];
6541                 c[1] *= rsurface.colormod[1];
6542                 c[2] *= rsurface.colormod[2];
6543                 c[3] *= rsurface.colormod[3];
6544         }
6545         if (r_refdef.fogenabled)
6546         {
6547                 for (i = 0, c = color4f;i < 6;i++, c += 4)
6548                 {
6549                         f1 = RSurf_FogVertex(rsurface.vertex3f + 3*i);
6550                         f2 = 1 - f1;
6551                         c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
6552                         c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
6553                         c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
6554                 }
6555         }
6556         R_Mesh_ResetTextureState();
6557         R_Mesh_Draw(0, 6, 0, 8, nomodelelement3i, nomodelelement3s, 0, 0);
6558 }
6559
6560 void R_DrawNoModel(entity_render_t *ent)
6561 {
6562         vec3_t org;
6563         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
6564         if ((ent->flags & RENDER_ADDITIVE) || (ent->alpha < 1))
6565                 R_MeshQueue_AddTransparent(ent->flags & RENDER_NODEPTHTEST ? r_refdef.view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
6566         else
6567                 R_DrawNoModel_TransparentCallback(ent, rsurface.rtlight, 0, NULL);
6568 }
6569
6570 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
6571 {
6572         vec3_t right1, right2, diff, normal;
6573
6574         VectorSubtract (org2, org1, normal);
6575
6576         // calculate 'right' vector for start
6577         VectorSubtract (r_refdef.view.origin, org1, diff);
6578         CrossProduct (normal, diff, right1);
6579         VectorNormalize (right1);
6580
6581         // calculate 'right' vector for end
6582         VectorSubtract (r_refdef.view.origin, org2, diff);
6583         CrossProduct (normal, diff, right2);
6584         VectorNormalize (right2);
6585
6586         vert[ 0] = org1[0] + width * right1[0];
6587         vert[ 1] = org1[1] + width * right1[1];
6588         vert[ 2] = org1[2] + width * right1[2];
6589         vert[ 3] = org1[0] - width * right1[0];
6590         vert[ 4] = org1[1] - width * right1[1];
6591         vert[ 5] = org1[2] - width * right1[2];
6592         vert[ 6] = org2[0] - width * right2[0];
6593         vert[ 7] = org2[1] - width * right2[1];
6594         vert[ 8] = org2[2] - width * right2[2];
6595         vert[ 9] = org2[0] + width * right2[0];
6596         vert[10] = org2[1] + width * right2[1];
6597         vert[11] = org2[2] + width * right2[2];
6598 }
6599
6600 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)
6601 {
6602         vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
6603         vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
6604         vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
6605         vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
6606         vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
6607         vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
6608         vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
6609         vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
6610         vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
6611         vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
6612         vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
6613         vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
6614 }
6615
6616 int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
6617 {
6618         int i;
6619         float *vertex3f;
6620         float v[3];
6621         VectorSet(v, x, y, z);
6622         for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
6623                 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
6624                         break;
6625         if (i == mesh->numvertices)
6626         {
6627                 if (mesh->numvertices < mesh->maxvertices)
6628                 {
6629                         VectorCopy(v, vertex3f);
6630                         mesh->numvertices++;
6631                 }
6632                 return mesh->numvertices;
6633         }
6634         else
6635                 return i;
6636 }
6637
6638 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
6639 {
6640         int i;
6641         int *e, element[3];
6642         element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
6643         element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
6644         e = mesh->element3i + mesh->numtriangles * 3;
6645         for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
6646         {
6647                 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
6648                 if (mesh->numtriangles < mesh->maxtriangles)
6649                 {
6650                         *e++ = element[0];
6651                         *e++ = element[1];
6652                         *e++ = element[2];
6653                         mesh->numtriangles++;
6654                 }
6655                 element[1] = element[2];
6656         }
6657 }
6658
6659 void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
6660 {
6661         int i;
6662         int *e, element[3];
6663         element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
6664         element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
6665         e = mesh->element3i + mesh->numtriangles * 3;
6666         for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
6667         {
6668                 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
6669                 if (mesh->numtriangles < mesh->maxtriangles)
6670                 {
6671                         *e++ = element[0];
6672                         *e++ = element[1];
6673                         *e++ = element[2];
6674                         mesh->numtriangles++;
6675                 }
6676                 element[1] = element[2];
6677         }
6678 }
6679
6680 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
6681 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
6682 {
6683         int planenum, planenum2;
6684         int w;
6685         int tempnumpoints;
6686         mplane_t *plane, *plane2;
6687         double maxdist;
6688         double temppoints[2][256*3];
6689         // figure out how large a bounding box we need to properly compute this brush
6690         maxdist = 0;
6691         for (w = 0;w < numplanes;w++)
6692                 maxdist = max(maxdist, fabs(planes[w].dist));
6693         // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
6694         maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
6695         for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
6696         {
6697                 w = 0;
6698                 tempnumpoints = 4;
6699                 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
6700                 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
6701                 {
6702                         if (planenum2 == planenum)
6703                                 continue;
6704                         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);
6705                         w = !w;
6706                 }
6707                 if (tempnumpoints < 3)
6708                         continue;
6709                 // generate elements forming a triangle fan for this polygon
6710                 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
6711         }
6712 }
6713
6714 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)
6715 {
6716         texturelayer_t *layer;
6717         layer = t->currentlayers + t->currentnumlayers++;
6718         layer->type = type;
6719         layer->depthmask = depthmask;
6720         layer->blendfunc1 = blendfunc1;
6721         layer->blendfunc2 = blendfunc2;
6722         layer->texture = texture;
6723         layer->texmatrix = *matrix;
6724         layer->color[0] = r;
6725         layer->color[1] = g;
6726         layer->color[2] = b;
6727         layer->color[3] = a;
6728 }
6729
6730 static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
6731 {
6732         double index, f;
6733         index = parms[2] + r_refdef.scene.time * parms[3];
6734         index -= floor(index);
6735         switch (func)
6736         {
6737         default:
6738         case Q3WAVEFUNC_NONE:
6739         case Q3WAVEFUNC_NOISE:
6740         case Q3WAVEFUNC_COUNT:
6741                 f = 0;
6742                 break;
6743         case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
6744         case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
6745         case Q3WAVEFUNC_SAWTOOTH: f = index;break;
6746         case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
6747         case Q3WAVEFUNC_TRIANGLE:
6748                 index *= 4;
6749                 f = index - floor(index);
6750                 if (index < 1)
6751                         f = f;
6752                 else if (index < 2)
6753                         f = 1 - f;
6754                 else if (index < 3)
6755                         f = -f;
6756                 else
6757                         f = -(1 - f);
6758                 break;
6759         }
6760         return (float)(parms[0] + parms[1] * f);
6761 }
6762
6763 void R_tcMod_ApplyToMatrix(matrix4x4_t *texmatrix, q3shaderinfo_layer_tcmod_t *tcmod, int currentmaterialflags)
6764 {
6765         int w, h, idx;
6766         float f;
6767         float tcmat[12];
6768         matrix4x4_t matrix, temp;
6769         switch(tcmod->tcmod)
6770         {
6771                 case Q3TCMOD_COUNT:
6772                 case Q3TCMOD_NONE:
6773                         if (currentmaterialflags & MATERIALFLAG_WATERSCROLL)
6774                                 matrix = r_waterscrollmatrix;
6775                         else
6776                                 matrix = identitymatrix;
6777                         break;
6778                 case Q3TCMOD_ENTITYTRANSLATE:
6779                         // this is used in Q3 to allow the gamecode to control texcoord
6780                         // scrolling on the entity, which is not supported in darkplaces yet.
6781                         Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
6782                         break;
6783                 case Q3TCMOD_ROTATE:
6784                         Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
6785                         Matrix4x4_ConcatRotate(&matrix, tcmod->parms[0] * r_refdef.scene.time, 0, 0, 1);
6786                         Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
6787                         break;
6788                 case Q3TCMOD_SCALE:
6789                         Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
6790                         break;
6791                 case Q3TCMOD_SCROLL:
6792                         Matrix4x4_CreateTranslate(&matrix, tcmod->parms[0] * r_refdef.scene.time, tcmod->parms[1] * r_refdef.scene.time, 0);
6793                         break;
6794                 case Q3TCMOD_PAGE: // poor man's animmap (to store animations into a single file, useful for HTTP downloaded textures)
6795                         w = (int) tcmod->parms[0];
6796                         h = (int) tcmod->parms[1];
6797                         f = r_refdef.scene.time / (tcmod->parms[2] * w * h);
6798                         f = f - floor(f);
6799                         idx = (int) floor(f * w * h);
6800                         Matrix4x4_CreateTranslate(&matrix, (idx % w) / tcmod->parms[0], (idx / w) / tcmod->parms[1], 0);
6801                         break;
6802                 case Q3TCMOD_STRETCH:
6803                         f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
6804                         Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
6805                         break;
6806                 case Q3TCMOD_TRANSFORM:
6807                         VectorSet(tcmat +  0, tcmod->parms[0], tcmod->parms[1], 0);
6808                         VectorSet(tcmat +  3, tcmod->parms[2], tcmod->parms[3], 0);
6809                         VectorSet(tcmat +  6, 0                   , 0                , 1);
6810                         VectorSet(tcmat +  9, tcmod->parms[4], tcmod->parms[5], 0);
6811                         Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
6812                         break;
6813                 case Q3TCMOD_TURBULENT:
6814                         // this is handled in the RSurf_PrepareVertices function
6815                         matrix = identitymatrix;
6816                         break;
6817         }
6818         temp = *texmatrix;
6819         Matrix4x4_Concat(texmatrix, &matrix, &temp);
6820 }
6821
6822 void R_LoadQWSkin(r_qwskincache_t *cache, const char *skinname)
6823 {
6824         int textureflags = (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_PICMIP | TEXF_COMPRESS;
6825         char name[MAX_QPATH];
6826         skinframe_t *skinframe;
6827         unsigned char pixels[296*194];
6828         strlcpy(cache->name, skinname, sizeof(cache->name));
6829         dpsnprintf(name, sizeof(name), "skins/%s.pcx", cache->name);
6830         if (developer_loading.integer)
6831                 Con_Printf("loading %s\n", name);
6832         skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
6833         if (!skinframe || !skinframe->base)
6834         {
6835                 unsigned char *f;
6836                 fs_offset_t filesize;
6837                 skinframe = NULL;
6838                 f = FS_LoadFile(name, tempmempool, true, &filesize);
6839                 if (f)
6840                 {
6841                         if (LoadPCX_QWSkin(f, filesize, pixels, 296, 194))
6842                                 skinframe = R_SkinFrame_LoadInternalQuake(name, textureflags, true, r_fullbrights.integer, pixels, image_width, image_height);
6843                         Mem_Free(f);
6844                 }
6845         }
6846         cache->skinframe = skinframe;
6847 }
6848
6849 texture_t *R_GetCurrentTexture(texture_t *t)
6850 {
6851         int i;
6852         const entity_render_t *ent = rsurface.entity;
6853         dp_model_t *model = ent->model;
6854         q3shaderinfo_layer_tcmod_t *tcmod;
6855
6856         if (t->update_lastrenderframe == r_frame && t->update_lastrenderentity == (void *)ent)
6857                 return t->currentframe;
6858         t->update_lastrenderframe = r_frame;
6859         t->update_lastrenderentity = (void *)ent;
6860
6861         // switch to an alternate material if this is a q1bsp animated material
6862         {
6863                 texture_t *texture = t;
6864                 int s = rsurface.ent_skinnum;
6865                 if ((unsigned int)s >= (unsigned int)model->numskins)
6866                         s = 0;
6867                 if (model->skinscenes)
6868                 {
6869                         if (model->skinscenes[s].framecount > 1)
6870                                 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.scene.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
6871                         else
6872                                 s = model->skinscenes[s].firstframe;
6873                 }
6874                 if (s > 0)
6875                         t = t + s * model->num_surfaces;
6876                 if (t->animated)
6877                 {
6878                         // use an alternate animation if the entity's frame is not 0,
6879                         // and only if the texture has an alternate animation
6880                         if (rsurface.ent_alttextures && t->anim_total[1])
6881                                 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[1]) : 0];
6882                         else
6883                                 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[0]) : 0];
6884                 }
6885                 texture->currentframe = t;
6886         }
6887
6888         // update currentskinframe to be a qw skin or animation frame
6889         if (rsurface.ent_qwskin >= 0)
6890         {
6891                 i = rsurface.ent_qwskin;
6892                 if (!r_qwskincache || r_qwskincache_size != cl.maxclients)
6893                 {
6894                         r_qwskincache_size = cl.maxclients;
6895                         if (r_qwskincache)
6896                                 Mem_Free(r_qwskincache);
6897                         r_qwskincache = Mem_Alloc(r_main_mempool, sizeof(*r_qwskincache) * r_qwskincache_size);
6898                 }
6899                 if (strcmp(r_qwskincache[i].name, cl.scores[i].qw_skin))
6900                         R_LoadQWSkin(&r_qwskincache[i], cl.scores[i].qw_skin);
6901                 t->currentskinframe = r_qwskincache[i].skinframe;
6902                 if (t->currentskinframe == NULL)
6903                         t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
6904         }
6905         else if (t->numskinframes >= 2)
6906                 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
6907         if (t->backgroundnumskinframes >= 2)
6908                 t->backgroundcurrentskinframe = t->backgroundskinframes[(int)(t->backgroundskinframerate * (cl.time - rsurface.ent_shadertime)) % t->backgroundnumskinframes];
6909
6910         t->currentmaterialflags = t->basematerialflags;
6911         t->currentalpha = rsurface.colormod[3];
6912         if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
6913                 t->currentalpha *= r_wateralpha.value;
6914         if(t->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay)
6915                 t->currentalpha *= t->r_water_wateralpha;
6916         if(!r_waterstate.enabled || r_refdef.view.isoverlay)
6917                 t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION);
6918         if (!(rsurface.ent_flags & RENDER_LIGHT))
6919                 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
6920         else if (rsurface.modeltexcoordlightmap2f == NULL && !(t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
6921         {
6922                 // pick a model lighting mode
6923                 if (VectorLength2(rsurface.modellight_diffuse) >= (1.0f / 256.0f))
6924                         t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
6925                 else
6926                         t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
6927         }
6928         if (rsurface.ent_flags & RENDER_ADDITIVE)
6929                 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
6930         else if (t->currentalpha < 1)
6931                 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
6932         if (rsurface.ent_flags & RENDER_DOUBLESIDED)
6933                 t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
6934         if (rsurface.ent_flags & (RENDER_NODEPTHTEST | RENDER_VIEWMODEL))
6935                 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
6936         if (t->backgroundnumskinframes)
6937                 t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
6938         if (t->currentmaterialflags & MATERIALFLAG_BLENDED)
6939         {
6940                 if (t->currentmaterialflags & (MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER))
6941                         t->currentmaterialflags &= ~MATERIALFLAG_BLENDED;
6942         }
6943         else
6944                 t->currentmaterialflags &= ~(MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER);
6945         if ((t->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST)) == MATERIALFLAG_BLENDED && r_transparentdepthmasking.integer && !(t->basematerialflags & MATERIALFLAG_BLENDED))
6946                 t->currentmaterialflags |= MATERIALFLAG_TRANSDEPTH;
6947
6948         // there is no tcmod
6949         if (t->currentmaterialflags & MATERIALFLAG_WATERSCROLL)
6950         {
6951                 t->currenttexmatrix = r_waterscrollmatrix;
6952                 t->currentbackgroundtexmatrix = r_waterscrollmatrix;
6953         }
6954         else if (!(t->currentmaterialflags & MATERIALFLAG_CUSTOMSURFACE))
6955         {
6956                 Matrix4x4_CreateIdentity(&t->currenttexmatrix);
6957                 Matrix4x4_CreateIdentity(&t->currentbackgroundtexmatrix);
6958         }
6959
6960         for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
6961                 R_tcMod_ApplyToMatrix(&t->currenttexmatrix, tcmod, t->currentmaterialflags);
6962         for (i = 0, tcmod = t->backgroundtcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
6963                 R_tcMod_ApplyToMatrix(&t->currentbackgroundtexmatrix, tcmod, t->currentmaterialflags);
6964
6965         t->colormapping = VectorLength2(rsurface.colormap_pantscolor) + VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f);
6966         if (t->currentskinframe->qpixels)
6967                 R_SkinFrame_GenerateTexturesFromQPixels(t->currentskinframe, t->colormapping);
6968         t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
6969         t->pantstexture = t->colormapping ? t->currentskinframe->pants : NULL;
6970         t->shirttexture = t->colormapping ? t->currentskinframe->shirt : NULL;
6971         t->nmaptexture = t->currentskinframe->nmap;
6972         t->glosstexture = r_texture_black;
6973         t->glowtexture = t->currentskinframe->glow;
6974         t->fogtexture = t->currentskinframe->fog;
6975         if (t->backgroundnumskinframes)
6976         {
6977                 t->backgroundbasetexture = (!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base;
6978                 t->backgroundnmaptexture = t->backgroundcurrentskinframe->nmap;
6979                 t->backgroundglosstexture = r_texture_black;
6980                 t->backgroundglowtexture = t->backgroundcurrentskinframe->glow;
6981         }
6982         else
6983         {
6984                 t->backgroundbasetexture = t->backgroundnumskinframes ? ((!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base) : r_texture_white;
6985                 t->backgroundnmaptexture = r_texture_blanknormalmap;
6986                 t->backgroundglosstexture = r_texture_black;
6987                 t->backgroundglowtexture = NULL;
6988         }
6989         t->specularpower = r_shadow_glossexponent.value;
6990         // TODO: store reference values for these in the texture?
6991         t->specularscale = 0;
6992         if (r_shadow_gloss.integer > 0)
6993         {
6994                 if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
6995                 {
6996                         if (r_shadow_glossintensity.value > 0)
6997                         {
6998                                 t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
6999                                 t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
7000                                 t->specularscale = r_shadow_glossintensity.value;
7001                         }
7002                 }
7003                 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
7004                 {
7005                         t->glosstexture = r_texture_white;
7006                         t->backgroundglosstexture = r_texture_white;
7007                         t->specularscale = r_shadow_gloss2intensity.value;
7008                         t->specularpower = r_shadow_gloss2exponent.value;
7009                 }
7010         }
7011         t->specularscale *= t->specularscalemod;
7012         t->specularpower *= t->specularpowermod;
7013
7014         // lightmaps mode looks bad with dlights using actual texturing, so turn
7015         // off the colormap and glossmap, but leave the normalmap on as it still
7016         // accurately represents the shading involved
7017         if (gl_lightmaps.integer)
7018         {
7019                 t->basetexture = r_texture_grey128;
7020                 t->pantstexture = r_texture_black;
7021                 t->shirttexture = r_texture_black;
7022                 t->nmaptexture = r_texture_blanknormalmap;
7023                 t->glosstexture = r_texture_black;
7024                 t->glowtexture = NULL;
7025                 t->fogtexture = NULL;
7026                 t->backgroundbasetexture = NULL;
7027                 t->backgroundnmaptexture = r_texture_blanknormalmap;
7028                 t->backgroundglosstexture = r_texture_black;
7029                 t->backgroundglowtexture = NULL;
7030                 t->specularscale = 0;
7031                 t->currentmaterialflags = MATERIALFLAG_WALL | (t->currentmaterialflags & (MATERIALFLAG_NOCULLFACE | MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SHORTDEPTHRANGE));
7032         }
7033
7034         Vector4Set(t->lightmapcolor, rsurface.colormod[0], rsurface.colormod[1], rsurface.colormod[2], t->currentalpha);
7035         VectorClear(t->dlightcolor);
7036         t->currentnumlayers = 0;
7037         if (t->currentmaterialflags & MATERIALFLAG_WALL)
7038         {
7039                 int blendfunc1, blendfunc2;
7040                 qboolean depthmask;
7041                 if (t->currentmaterialflags & MATERIALFLAG_ADD)
7042                 {
7043                         blendfunc1 = GL_SRC_ALPHA;
7044                         blendfunc2 = GL_ONE;
7045                 }
7046                 else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
7047                 {
7048                         blendfunc1 = GL_SRC_ALPHA;
7049                         blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
7050                 }
7051                 else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
7052                 {
7053                         blendfunc1 = t->customblendfunc[0];
7054                         blendfunc2 = t->customblendfunc[1];
7055                 }
7056                 else
7057                 {
7058                         blendfunc1 = GL_ONE;
7059                         blendfunc2 = GL_ZERO;
7060                 }
7061                 depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
7062                 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
7063                 {
7064                         // fullbright is not affected by r_refdef.lightmapintensity
7065                         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]);
7066                         if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
7067                                 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]);
7068                         if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
7069                                 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]);
7070                 }
7071                 else
7072                 {
7073                         vec3_t ambientcolor;
7074                         float colorscale;
7075                         // set the color tint used for lights affecting this surface
7076                         VectorSet(t->dlightcolor, t->lightmapcolor[0] * t->lightmapcolor[3], t->lightmapcolor[1] * t->lightmapcolor[3], t->lightmapcolor[2] * t->lightmapcolor[3]);
7077                         colorscale = 2;
7078                         // q3bsp has no lightmap updates, so the lightstylevalue that
7079                         // would normally be baked into the lightmap must be
7080                         // applied to the color
7081                         // FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
7082                         if (model->type == mod_brushq3)
7083                                 colorscale *= r_refdef.scene.rtlightstylevalue[0];
7084                         colorscale *= r_refdef.lightmapintensity;
7085                         VectorScale(t->lightmapcolor, r_refdef.scene.ambient, ambientcolor);
7086                         VectorScale(t->lightmapcolor, colorscale, t->lightmapcolor);
7087                         // basic lit geometry
7088                         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]);
7089                         // add pants/shirt if needed
7090                         if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
7091                                 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]);
7092                         if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
7093                                 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]);
7094                         // now add ambient passes if needed
7095                         if (VectorLength2(ambientcolor) >= (1.0f/1048576.0f))
7096                         {
7097                                 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]);
7098                                 if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
7099                                         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]);
7100                                 if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
7101                                         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]);
7102                         }
7103                 }
7104                 if (t->glowtexture != NULL && !gl_lightmaps.integer)
7105                         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]);
7106                 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
7107                 {
7108                         // if this is opaque use alpha blend which will darken the earlier
7109                         // passes cheaply.
7110                         //
7111                         // if this is an alpha blended material, all the earlier passes
7112                         // were darkened by fog already, so we only need to add the fog
7113                         // color ontop through the fog mask texture
7114                         //
7115                         // if this is an additive blended material, all the earlier passes
7116                         // were darkened by fog already, and we should not add fog color
7117                         // (because the background was not darkened, there is no fog color
7118                         // that was lost behind it).
7119                         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]);
7120                 }
7121         }
7122
7123         return t->currentframe;
7124 }
7125
7126 rsurfacestate_t rsurface;
7127
7128 void R_Mesh_ResizeArrays(int newvertices)
7129 {
7130         float *base;
7131         if (rsurface.array_size >= newvertices)
7132                 return;
7133         if (rsurface.array_modelvertex3f)
7134                 Mem_Free(rsurface.array_modelvertex3f);
7135         rsurface.array_size = (newvertices + 1023) & ~1023;
7136         base = (float *)Mem_Alloc(r_main_mempool, rsurface.array_size * sizeof(float[33]));
7137         rsurface.array_modelvertex3f     = base + rsurface.array_size * 0;
7138         rsurface.array_modelsvector3f    = base + rsurface.array_size * 3;
7139         rsurface.array_modeltvector3f    = base + rsurface.array_size * 6;
7140         rsurface.array_modelnormal3f     = base + rsurface.array_size * 9;
7141         rsurface.array_deformedvertex3f  = base + rsurface.array_size * 12;
7142         rsurface.array_deformedsvector3f = base + rsurface.array_size * 15;
7143         rsurface.array_deformedtvector3f = base + rsurface.array_size * 18;
7144         rsurface.array_deformednormal3f  = base + rsurface.array_size * 21;
7145         rsurface.array_texcoord3f        = base + rsurface.array_size * 24;
7146         rsurface.array_color4f           = base + rsurface.array_size * 27;
7147         rsurface.array_generatedtexcoordtexture2f = base + rsurface.array_size * 31;
7148 }
7149
7150 void RSurf_ActiveWorldEntity(void)
7151 {
7152         dp_model_t *model = r_refdef.scene.worldmodel;
7153         //if (rsurface.entity == r_refdef.scene.worldentity)
7154         //      return;
7155         rsurface.entity = r_refdef.scene.worldentity;
7156         rsurface.skeleton = NULL;
7157         rsurface.ent_skinnum = 0;
7158         rsurface.ent_qwskin = -1;
7159         rsurface.ent_shadertime = 0;
7160         rsurface.ent_flags = r_refdef.scene.worldentity->flags;
7161         if (rsurface.array_size < model->surfmesh.num_vertices)
7162                 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
7163         rsurface.matrix = identitymatrix;
7164         rsurface.inversematrix = identitymatrix;
7165         rsurface.matrixscale = 1;
7166         rsurface.inversematrixscale = 1;
7167         R_EntityMatrix(&identitymatrix);
7168         VectorCopy(r_refdef.view.origin, rsurface.localvieworigin);
7169         Vector4Copy(r_refdef.fogplane, rsurface.fogplane);
7170         rsurface.fograngerecip = r_refdef.fograngerecip;
7171         rsurface.fogheightfade = r_refdef.fogheightfade;
7172         rsurface.fogplaneviewdist = r_refdef.fogplaneviewdist;
7173         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
7174         VectorSet(rsurface.modellight_ambient, 0, 0, 0);
7175         VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
7176         VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
7177         VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
7178         VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
7179         VectorSet(rsurface.colormod, r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale);
7180         rsurface.colormod[3] = 1;
7181         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);
7182         memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
7183         rsurface.frameblend[0].lerp = 1;
7184         rsurface.ent_alttextures = false;
7185         rsurface.basepolygonfactor = r_refdef.polygonfactor;
7186         rsurface.basepolygonoffset = r_refdef.polygonoffset;
7187         rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
7188         rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
7189         rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
7190         rsurface.modelsvector3f = model->surfmesh.data_svector3f;
7191         rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
7192         rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
7193         rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
7194         rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
7195         rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
7196         rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
7197         rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
7198         rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
7199         rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
7200         rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
7201         rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
7202         rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
7203         rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
7204         rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
7205         rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
7206         rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
7207         rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
7208         rsurface.modelelement3i = model->surfmesh.data_element3i;
7209         rsurface.modelelement3s = model->surfmesh.data_element3s;
7210         rsurface.modelelement3i_bufferobject = model->surfmesh.ebo3i;
7211         rsurface.modelelement3s_bufferobject = model->surfmesh.ebo3s;
7212         rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
7213         rsurface.modelnum_vertices = model->surfmesh.num_vertices;
7214         rsurface.modelnum_triangles = model->surfmesh.num_triangles;
7215         rsurface.modelsurfaces = model->data_surfaces;
7216         rsurface.generatedvertex = false;
7217         rsurface.vertex3f  = rsurface.modelvertex3f;
7218         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
7219         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
7220         rsurface.svector3f = rsurface.modelsvector3f;
7221         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
7222         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
7223         rsurface.tvector3f = rsurface.modeltvector3f;
7224         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
7225         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
7226         rsurface.normal3f  = rsurface.modelnormal3f;
7227         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
7228         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
7229         rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
7230 }
7231
7232 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents, qboolean prepass)
7233 {
7234         dp_model_t *model = ent->model;
7235         //if (rsurface.entity == ent && (!model->surfmesh.isanimated || (!wantnormals && !wanttangents)))
7236         //      return;
7237         rsurface.entity = (entity_render_t *)ent;
7238         rsurface.skeleton = ent->skeleton;
7239         rsurface.ent_skinnum = ent->skinnum;
7240         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;
7241         rsurface.ent_shadertime = ent->shadertime;
7242         rsurface.ent_flags = ent->flags;
7243         if (rsurface.array_size < model->surfmesh.num_vertices)
7244                 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
7245         rsurface.matrix = ent->matrix;
7246         rsurface.inversematrix = ent->inversematrix;
7247         rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
7248         rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
7249         R_EntityMatrix(&rsurface.matrix);
7250         Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
7251         Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
7252         rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
7253         rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
7254         rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
7255         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
7256         VectorCopy(ent->modellight_ambient, rsurface.modellight_ambient);
7257         VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
7258         VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
7259         VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
7260         VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
7261         VectorScale(ent->colormod, r_refdef.view.colorscale, rsurface.colormod);
7262         rsurface.colormod[3] = ent->alpha;
7263         VectorScale(ent->glowmod, r_refdef.view.colorscale * r_hdr_glowintensity.value, rsurface.glowmod);
7264         memcpy(rsurface.frameblend, ent->frameblend, sizeof(ent->frameblend));
7265         rsurface.ent_alttextures = ent->framegroupblend[0].frame != 0;
7266         rsurface.basepolygonfactor = r_refdef.polygonfactor;
7267         rsurface.basepolygonoffset = r_refdef.polygonoffset;
7268         if (ent->model->brush.submodel && !prepass)
7269         {
7270                 rsurface.basepolygonfactor += r_polygonoffset_submodel_factor.value;
7271                 rsurface.basepolygonoffset += r_polygonoffset_submodel_offset.value;
7272         }
7273         if (model->surfmesh.isanimated && model->AnimateVertices && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].subframe != 0))
7274         {
7275                 if (ent->animcache_vertex3f && !r_framedata_failed)
7276                 {
7277                         rsurface.modelvertex3f = ent->animcache_vertex3f;
7278                         rsurface.modelsvector3f = wanttangents ? ent->animcache_svector3f : NULL;
7279                         rsurface.modeltvector3f = wanttangents ? ent->animcache_tvector3f : NULL;
7280                         rsurface.modelnormal3f = wantnormals ? ent->animcache_normal3f : NULL;
7281                 }
7282                 else if (wanttangents)
7283                 {
7284                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
7285                         rsurface.modelsvector3f = rsurface.array_modelsvector3f;
7286                         rsurface.modeltvector3f = rsurface.array_modeltvector3f;
7287                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
7288                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f);
7289                 }
7290                 else if (wantnormals)
7291                 {
7292                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
7293                         rsurface.modelsvector3f = NULL;
7294                         rsurface.modeltvector3f = NULL;
7295                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
7296                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL);
7297                 }
7298                 else
7299                 {
7300                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
7301                         rsurface.modelsvector3f = NULL;
7302                         rsurface.modeltvector3f = NULL;
7303                         rsurface.modelnormal3f = NULL;
7304                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, NULL, NULL, NULL);
7305                 }
7306                 rsurface.modelvertex3f_bufferobject = 0;
7307                 rsurface.modelvertex3f_bufferoffset = 0;
7308                 rsurface.modelsvector3f_bufferobject = 0;
7309                 rsurface.modelsvector3f_bufferoffset = 0;
7310                 rsurface.modeltvector3f_bufferobject = 0;
7311                 rsurface.modeltvector3f_bufferoffset = 0;
7312                 rsurface.modelnormal3f_bufferobject = 0;
7313                 rsurface.modelnormal3f_bufferoffset = 0;
7314                 rsurface.generatedvertex = true;
7315         }
7316         else
7317         {
7318                 rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
7319                 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
7320                 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
7321                 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
7322                 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
7323                 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
7324                 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
7325                 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
7326                 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
7327                 rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
7328                 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
7329                 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
7330                 rsurface.generatedvertex = false;
7331         }
7332         rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
7333         rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
7334         rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
7335         rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
7336         rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
7337         rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
7338         rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
7339         rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
7340         rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
7341         rsurface.modelelement3i = model->surfmesh.data_element3i;
7342         rsurface.modelelement3s = model->surfmesh.data_element3s;
7343         rsurface.modelelement3i_bufferobject = model->surfmesh.ebo3i;
7344         rsurface.modelelement3s_bufferobject = model->surfmesh.ebo3s;
7345         rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
7346         rsurface.modelnum_vertices = model->surfmesh.num_vertices;
7347         rsurface.modelnum_triangles = model->surfmesh.num_triangles;
7348         rsurface.modelsurfaces = model->data_surfaces;
7349         rsurface.vertex3f  = rsurface.modelvertex3f;
7350         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
7351         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
7352         rsurface.svector3f = rsurface.modelsvector3f;
7353         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
7354         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
7355         rsurface.tvector3f = rsurface.modeltvector3f;
7356         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
7357         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
7358         rsurface.normal3f  = rsurface.modelnormal3f;
7359         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
7360         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
7361         rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
7362 }
7363
7364 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)
7365 {
7366         rsurface.entity = r_refdef.scene.worldentity;
7367         rsurface.skeleton = NULL;
7368         rsurface.ent_skinnum = 0;
7369         rsurface.ent_qwskin = -1;
7370         rsurface.ent_shadertime = shadertime;
7371         rsurface.ent_flags = entflags;
7372         rsurface.modelnum_vertices = numvertices;
7373         rsurface.modelnum_triangles = numtriangles;
7374         if (rsurface.array_size < rsurface.modelnum_vertices)
7375                 R_Mesh_ResizeArrays(rsurface.modelnum_vertices);
7376         rsurface.matrix = *matrix;
7377         rsurface.inversematrix = *inversematrix;
7378         rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
7379         rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
7380         R_EntityMatrix(&rsurface.matrix);
7381         Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
7382         Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
7383         rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
7384         rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
7385         rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
7386         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
7387         VectorSet(rsurface.modellight_ambient, 0, 0, 0);
7388         VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
7389         VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
7390         VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
7391         VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
7392         Vector4Set(rsurface.colormod, r * r_refdef.view.colorscale, g * r_refdef.view.colorscale, b * r_refdef.view.colorscale, a);
7393         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);
7394         memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
7395         rsurface.frameblend[0].lerp = 1;
7396         rsurface.ent_alttextures = false;
7397         rsurface.basepolygonfactor = r_refdef.polygonfactor;
7398         rsurface.basepolygonoffset = r_refdef.polygonoffset;
7399         if (wanttangents)
7400         {
7401                 rsurface.modelvertex3f = vertex3f;
7402                 rsurface.modelsvector3f = svector3f ? svector3f : rsurface.array_modelsvector3f;
7403                 rsurface.modeltvector3f = tvector3f ? tvector3f : rsurface.array_modeltvector3f;
7404                 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
7405         }
7406         else if (wantnormals)
7407         {
7408                 rsurface.modelvertex3f = vertex3f;
7409                 rsurface.modelsvector3f = NULL;
7410                 rsurface.modeltvector3f = NULL;
7411                 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
7412         }
7413         else
7414         {
7415                 rsurface.modelvertex3f = vertex3f;
7416                 rsurface.modelsvector3f = NULL;
7417                 rsurface.modeltvector3f = NULL;
7418                 rsurface.modelnormal3f = NULL;
7419         }
7420         rsurface.modelvertex3f_bufferobject = 0;
7421         rsurface.modelvertex3f_bufferoffset = 0;
7422         rsurface.modelsvector3f_bufferobject = 0;
7423         rsurface.modelsvector3f_bufferoffset = 0;
7424         rsurface.modeltvector3f_bufferobject = 0;
7425         rsurface.modeltvector3f_bufferoffset = 0;
7426         rsurface.modelnormal3f_bufferobject = 0;
7427         rsurface.modelnormal3f_bufferoffset = 0;
7428         rsurface.generatedvertex = true;
7429         rsurface.modellightmapcolor4f  = color4f;
7430         rsurface.modellightmapcolor4f_bufferobject = 0;
7431         rsurface.modellightmapcolor4f_bufferoffset = 0;
7432         rsurface.modeltexcoordtexture2f  = texcoord2f;
7433         rsurface.modeltexcoordtexture2f_bufferobject = 0;
7434         rsurface.modeltexcoordtexture2f_bufferoffset = 0;
7435         rsurface.modeltexcoordlightmap2f  = NULL;
7436         rsurface.modeltexcoordlightmap2f_bufferobject = 0;
7437         rsurface.modeltexcoordlightmap2f_bufferoffset = 0;
7438         rsurface.modelelement3i = element3i;
7439         rsurface.modelelement3s = element3s;
7440         rsurface.modelelement3i_bufferobject = 0;
7441         rsurface.modelelement3s_bufferobject = 0;
7442         rsurface.modellightmapoffsets = NULL;
7443         rsurface.modelsurfaces = NULL;
7444         rsurface.vertex3f  = rsurface.modelvertex3f;
7445         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
7446         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
7447         rsurface.svector3f = rsurface.modelsvector3f;
7448         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
7449         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
7450         rsurface.tvector3f = rsurface.modeltvector3f;
7451         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
7452         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
7453         rsurface.normal3f  = rsurface.modelnormal3f;
7454         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
7455         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
7456         rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
7457
7458         if (rsurface.modelnum_vertices && rsurface.modelelement3i)
7459         {
7460                 if ((wantnormals || wanttangents) && !normal3f)
7461                         Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
7462                 if (wanttangents && !svector3f)
7463                         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);
7464         }
7465 }
7466
7467 float RSurf_FogPoint(const float *v)
7468 {
7469         // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
7470         float FogPlaneViewDist = r_refdef.fogplaneviewdist;
7471         float FogPlaneVertexDist = DotProduct(r_refdef.fogplane, v) + r_refdef.fogplane[3];
7472         float FogHeightFade = r_refdef.fogheightfade;
7473         float fogfrac;
7474         unsigned int fogmasktableindex;
7475         if (r_refdef.fogplaneviewabove)
7476                 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
7477         else
7478                 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
7479         fogmasktableindex = (unsigned int)(VectorDistance(r_refdef.view.origin, v) * fogfrac * r_refdef.fogmasktabledistmultiplier);
7480         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
7481 }
7482
7483 float RSurf_FogVertex(const float *v)
7484 {
7485         // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
7486         float FogPlaneViewDist = rsurface.fogplaneviewdist;
7487         float FogPlaneVertexDist = DotProduct(rsurface.fogplane, v) + rsurface.fogplane[3];
7488         float FogHeightFade = rsurface.fogheightfade;
7489         float fogfrac;
7490         unsigned int fogmasktableindex;
7491         if (r_refdef.fogplaneviewabove)
7492                 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
7493         else
7494                 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
7495         fogmasktableindex = (unsigned int)(VectorDistance(rsurface.localvieworigin, v) * fogfrac * rsurface.fogmasktabledistmultiplier);
7496         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
7497 }
7498
7499 static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
7500 void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, const msurface_t **texturesurfacelist)
7501 {
7502         int deformindex;
7503         int texturesurfaceindex;
7504         int i, j;
7505         float amplitude;
7506         float animpos;
7507         float scale;
7508         const float *v1, *in_tc;
7509         float *out_tc;
7510         float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
7511         float waveparms[4];
7512         q3shaderinfo_deform_t *deform;
7513         // 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
7514         if (rsurface.generatedvertex)
7515         {
7516                 if (rsurface.texture->tcgen.tcgen == Q3TCGEN_ENVIRONMENT)
7517                         generatenormals = true;
7518                 for (i = 0;i < Q3MAXDEFORMS;i++)
7519                 {
7520                         if (rsurface.texture->deforms[i].deform == Q3DEFORM_AUTOSPRITE)
7521                         {
7522                                 generatetangents = true;
7523                                 generatenormals = true;
7524                         }
7525                         if (rsurface.texture->deforms[i].deform != Q3DEFORM_NONE)
7526                                 generatenormals = true;
7527                 }
7528                 if (generatenormals && !rsurface.modelnormal3f)
7529                 {
7530                         rsurface.normal3f = rsurface.modelnormal3f = rsurface.array_modelnormal3f;
7531                         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject = 0;
7532                         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset = 0;
7533                         Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
7534                 }
7535                 if (generatetangents && !rsurface.modelsvector3f)
7536                 {
7537                         rsurface.svector3f = rsurface.modelsvector3f = rsurface.array_modelsvector3f;
7538                         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject = 0;
7539                         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset = 0;
7540                         rsurface.tvector3f = rsurface.modeltvector3f = rsurface.array_modeltvector3f;
7541                         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject = 0;
7542                         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset = 0;
7543                         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);
7544                 }
7545         }
7546         rsurface.vertex3f  = rsurface.modelvertex3f;
7547         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
7548         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
7549         rsurface.svector3f = rsurface.modelsvector3f;
7550         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
7551         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
7552         rsurface.tvector3f = rsurface.modeltvector3f;
7553         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
7554         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
7555         rsurface.normal3f  = rsurface.modelnormal3f;
7556         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
7557         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
7558         // if vertices are deformed (sprite flares and things in maps, possibly
7559         // water waves, bulges and other deformations), generate them into
7560         // rsurface.deform* arrays from whatever the rsurface.* arrays point to
7561         // (may be static model data or generated data for an animated model, or
7562         //  the previous deform pass)
7563         for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
7564         {
7565                 switch (deform->deform)
7566                 {
7567                 default:
7568                 case Q3DEFORM_PROJECTIONSHADOW:
7569                 case Q3DEFORM_TEXT0:
7570                 case Q3DEFORM_TEXT1:
7571                 case Q3DEFORM_TEXT2:
7572                 case Q3DEFORM_TEXT3:
7573                 case Q3DEFORM_TEXT4:
7574                 case Q3DEFORM_TEXT5:
7575                 case Q3DEFORM_TEXT6:
7576                 case Q3DEFORM_TEXT7:
7577                 case Q3DEFORM_NONE:
7578                         break;
7579                 case Q3DEFORM_AUTOSPRITE:
7580                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
7581                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
7582                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
7583                         VectorNormalize(newforward);
7584                         VectorNormalize(newright);
7585                         VectorNormalize(newup);
7586                         // make deformed versions of only the model vertices used by the specified surfaces
7587                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7588                         {
7589                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7590                                 // a single autosprite surface can contain multiple sprites...
7591                                 for (j = 0;j < surface->num_vertices - 3;j += 4)
7592                                 {
7593                                         VectorClear(center);
7594                                         for (i = 0;i < 4;i++)
7595                                                 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
7596                                         VectorScale(center, 0.25f, center);
7597                                         VectorCopy((rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, forward);
7598                                         VectorCopy((rsurface.svector3f + 3 * surface->num_firstvertex) + j*3, right);
7599                                         VectorCopy((rsurface.tvector3f + 3 * surface->num_firstvertex) + j*3, up);
7600                                         for (i = 0;i < 4;i++)
7601                                         {
7602                                                 VectorSubtract((rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, center, v);
7603                                                 VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
7604                                         }
7605                                 }
7606                                 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);
7607                                 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);
7608                         }
7609                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
7610                         rsurface.vertex3f_bufferobject = 0;
7611                         rsurface.vertex3f_bufferoffset = 0;
7612                         rsurface.svector3f = rsurface.array_deformedsvector3f;
7613                         rsurface.svector3f_bufferobject = 0;
7614                         rsurface.svector3f_bufferoffset = 0;
7615                         rsurface.tvector3f = rsurface.array_deformedtvector3f;
7616                         rsurface.tvector3f_bufferobject = 0;
7617                         rsurface.tvector3f_bufferoffset = 0;
7618                         rsurface.normal3f = rsurface.array_deformednormal3f;
7619                         rsurface.normal3f_bufferobject = 0;
7620                         rsurface.normal3f_bufferoffset = 0;
7621                         break;
7622                 case Q3DEFORM_AUTOSPRITE2:
7623                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
7624                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
7625                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
7626                         VectorNormalize(newforward);
7627                         VectorNormalize(newright);
7628                         VectorNormalize(newup);
7629                         // make deformed versions of only the model vertices used by the specified surfaces
7630                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7631                         {
7632                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7633                                 const float *v1, *v2;
7634                                 vec3_t start, end;
7635                                 float f, l;
7636                                 struct
7637                                 {
7638                                         float length2;
7639                                         const float *v1;
7640                                         const float *v2;
7641                                 }
7642                                 shortest[2];
7643                                 memset(shortest, 0, sizeof(shortest));
7644                                 // a single autosprite surface can contain multiple sprites...
7645                                 for (j = 0;j < surface->num_vertices - 3;j += 4)
7646                                 {
7647                                         VectorClear(center);
7648                                         for (i = 0;i < 4;i++)
7649                                                 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
7650                                         VectorScale(center, 0.25f, center);
7651                                         // find the two shortest edges, then use them to define the
7652                                         // axis vectors for rotating around the central axis
7653                                         for (i = 0;i < 6;i++)
7654                                         {
7655                                                 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][0]);
7656                                                 v2 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][1]);
7657 #if 0
7658                                                 Debug_PolygonBegin(NULL, 0);
7659                                                 Debug_PolygonVertex(v1[0], v1[1], v1[2], 0, 0, 1, 0, 0, 1);
7660                                                 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);
7661                                                 Debug_PolygonVertex(v2[0], v2[1], v2[2], 0, 0, 1, 0, 0, 1);
7662                                                 Debug_PolygonEnd();
7663 #endif
7664                                                 l = VectorDistance2(v1, v2);
7665                                                 // this length bias tries to make sense of square polygons, assuming they are meant to be upright
7666                                                 if (v1[2] != v2[2])
7667                                                         l += (1.0f / 1024.0f);
7668                                                 if (shortest[0].length2 > l || i == 0)
7669                                                 {
7670                                                         shortest[1] = shortest[0];
7671                                                         shortest[0].length2 = l;
7672                                                         shortest[0].v1 = v1;
7673                                                         shortest[0].v2 = v2;
7674                                                 }
7675                                                 else if (shortest[1].length2 > l || i == 1)
7676                                                 {
7677                                                         shortest[1].length2 = l;
7678                                                         shortest[1].v1 = v1;
7679                                                         shortest[1].v2 = v2;
7680                                                 }
7681                                         }
7682                                         VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
7683                                         VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
7684 #if 0
7685                                         Debug_PolygonBegin(NULL, 0);
7686                                         Debug_PolygonVertex(start[0], start[1], start[2], 0, 0, 1, 1, 0, 1);
7687                                         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);
7688                                         Debug_PolygonVertex(end[0], end[1], end[2], 0, 0, 0, 1, 1, 1);
7689                                         Debug_PolygonEnd();
7690 #endif
7691                                         // this calculates the right vector from the shortest edge
7692                                         // and the up vector from the edge midpoints
7693                                         VectorSubtract(shortest[0].v1, shortest[0].v2, right);
7694                                         VectorNormalize(right);
7695                                         VectorSubtract(end, start, up);
7696                                         VectorNormalize(up);
7697                                         // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
7698                                         VectorSubtract(rsurface.localvieworigin, center, forward);
7699                                         //Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, forward);
7700                                         VectorNegate(forward, forward);
7701                                         VectorReflect(forward, 0, up, forward);
7702                                         VectorNormalize(forward);
7703                                         CrossProduct(up, forward, newright);
7704                                         VectorNormalize(newright);
7705 #if 0
7706                                         Debug_PolygonBegin(NULL, 0);
7707                                         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);
7708                                         Debug_PolygonVertex(center[0] + right[0] * 8, center[1] + right[1] * 8, center[2] + right[2] * 8, 0, 0, 0, 1, 0, 1);
7709                                         Debug_PolygonVertex(center[0] + up   [0] * 8, center[1] + up   [1] * 8, center[2] + up   [2] * 8, 0, 0, 0, 0, 1, 1);
7710                                         Debug_PolygonEnd();
7711 #endif
7712 #if 0
7713                                         Debug_PolygonBegin(NULL, 0);
7714                                         Debug_PolygonVertex(center[0] + forward [0] * 8, center[1] + forward [1] * 8, center[2] + forward [2] * 8, 0, 0, 1, 0, 0, 1);
7715                                         Debug_PolygonVertex(center[0] + newright[0] * 8, center[1] + newright[1] * 8, center[2] + newright[2] * 8, 0, 0, 0, 1, 0, 1);
7716                                         Debug_PolygonVertex(center[0] + up      [0] * 8, center[1] + up      [1] * 8, center[2] + up      [2] * 8, 0, 0, 0, 0, 1, 1);
7717                                         Debug_PolygonEnd();
7718 #endif
7719                                         // rotate the quad around the up axis vector, this is made
7720                                         // especially easy by the fact we know the quad is flat,
7721                                         // so we only have to subtract the center position and
7722                                         // measure distance along the right vector, and then
7723                                         // multiply that by the newright vector and add back the
7724                                         // center position
7725                                         // we also need to subtract the old position to undo the
7726                                         // displacement from the center, which we do with a
7727                                         // DotProduct, the subtraction/addition of center is also
7728                                         // optimized into DotProducts here
7729                                         l = DotProduct(right, center);
7730                                         for (i = 0;i < 4;i++)
7731                                         {
7732                                                 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + j + i);
7733                                                 f = DotProduct(right, v1) - l;
7734                                                 VectorMAMAM(1, v1, -f, right, f, newright, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
7735                                         }
7736                                 }
7737                                 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);
7738                                 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);
7739                         }
7740                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
7741                         rsurface.vertex3f_bufferobject = 0;
7742                         rsurface.vertex3f_bufferoffset = 0;
7743                         rsurface.svector3f = rsurface.array_deformedsvector3f;
7744                         rsurface.svector3f_bufferobject = 0;
7745                         rsurface.svector3f_bufferoffset = 0;
7746                         rsurface.tvector3f = rsurface.array_deformedtvector3f;
7747                         rsurface.tvector3f_bufferobject = 0;
7748                         rsurface.tvector3f_bufferoffset = 0;
7749                         rsurface.normal3f = rsurface.array_deformednormal3f;
7750                         rsurface.normal3f_bufferobject = 0;
7751                         rsurface.normal3f_bufferoffset = 0;
7752                         break;
7753                 case Q3DEFORM_NORMAL:
7754                         // deform the normals to make reflections wavey
7755                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7756                         {
7757                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7758                                 for (j = 0;j < surface->num_vertices;j++)
7759                                 {
7760                                         float vertex[3];
7761                                         float *normal = (rsurface.array_deformednormal3f  + 3 * surface->num_firstvertex) + j*3;
7762                                         VectorScale((rsurface.vertex3f  + 3 * surface->num_firstvertex) + j*3, 0.98f, vertex);
7763                                         VectorCopy((rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, normal);
7764                                         normal[0] += deform->parms[0] * noise4f(      vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
7765                                         normal[1] += deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
7766                                         normal[2] += deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
7767                                         VectorNormalize(normal);
7768                                 }
7769                                 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);
7770                         }
7771                         rsurface.svector3f = rsurface.array_deformedsvector3f;
7772                         rsurface.svector3f_bufferobject = 0;
7773                         rsurface.svector3f_bufferoffset = 0;
7774                         rsurface.tvector3f = rsurface.array_deformedtvector3f;
7775                         rsurface.tvector3f_bufferobject = 0;
7776                         rsurface.tvector3f_bufferoffset = 0;
7777                         rsurface.normal3f = rsurface.array_deformednormal3f;
7778                         rsurface.normal3f_bufferobject = 0;
7779                         rsurface.normal3f_bufferoffset = 0;
7780                         break;
7781                 case Q3DEFORM_WAVE:
7782                         // deform vertex array to make wavey water and flags and such
7783                         waveparms[0] = deform->waveparms[0];
7784                         waveparms[1] = deform->waveparms[1];
7785                         waveparms[2] = deform->waveparms[2];
7786                         waveparms[3] = deform->waveparms[3];
7787                         // this is how a divisor of vertex influence on deformation
7788                         animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
7789                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
7790                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7791                         {
7792                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7793                                 for (j = 0;j < surface->num_vertices;j++)
7794                                 {
7795                                         float *vertex = (rsurface.array_deformedvertex3f  + 3 * surface->num_firstvertex) + j*3;
7796                                         VectorCopy((rsurface.vertex3f  + 3 * surface->num_firstvertex) + j*3, vertex);
7797                                         // if the wavefunc depends on time, evaluate it per-vertex
7798                                         if (waveparms[3])
7799                                         {
7800                                                 waveparms[2] = deform->waveparms[2] + (vertex[0] + vertex[1] + vertex[2]) * animpos;
7801                                                 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
7802                                         }
7803                                         VectorMA(vertex, scale, (rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, vertex);
7804                                 }
7805                         }
7806                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
7807                         rsurface.vertex3f_bufferobject = 0;
7808                         rsurface.vertex3f_bufferoffset = 0;
7809                         break;
7810                 case Q3DEFORM_BULGE:
7811                         // deform vertex array to make the surface have moving bulges
7812                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7813                         {
7814                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7815                                 for (j = 0;j < surface->num_vertices;j++)
7816                                 {
7817                                         scale = sin((rsurface.modeltexcoordtexture2f[2 * (surface->num_firstvertex + j)] * deform->parms[0] + r_refdef.scene.time * deform->parms[2])) * deform->parms[1];
7818                                         VectorMA(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), scale, rsurface.normal3f + 3 * (surface->num_firstvertex + j), rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
7819                                 }
7820                         }
7821                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
7822                         rsurface.vertex3f_bufferobject = 0;
7823                         rsurface.vertex3f_bufferoffset = 0;
7824                         break;
7825                 case Q3DEFORM_MOVE:
7826                         // deform vertex array
7827                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
7828                         VectorScale(deform->parms, scale, waveparms);
7829                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7830                         {
7831                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7832                                 for (j = 0;j < surface->num_vertices;j++)
7833                                         VectorAdd(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), waveparms, rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
7834                         }
7835                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
7836                         rsurface.vertex3f_bufferobject = 0;
7837                         rsurface.vertex3f_bufferoffset = 0;
7838                         break;
7839                 }
7840         }
7841         // generate texcoords based on the chosen texcoord source
7842         switch(rsurface.texture->tcgen.tcgen)
7843         {
7844         default:
7845         case Q3TCGEN_TEXTURE:
7846                 rsurface.texcoordtexture2f               = rsurface.modeltexcoordtexture2f;
7847                 rsurface.texcoordtexture2f_bufferobject  = rsurface.modeltexcoordtexture2f_bufferobject;
7848                 rsurface.texcoordtexture2f_bufferoffset  = rsurface.modeltexcoordtexture2f_bufferoffset;
7849                 break;
7850         case Q3TCGEN_LIGHTMAP:
7851                 rsurface.texcoordtexture2f               = rsurface.modeltexcoordlightmap2f;
7852                 rsurface.texcoordtexture2f_bufferobject  = rsurface.modeltexcoordlightmap2f_bufferobject;
7853                 rsurface.texcoordtexture2f_bufferoffset  = rsurface.modeltexcoordlightmap2f_bufferoffset;
7854                 break;
7855         case Q3TCGEN_VECTOR:
7856                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7857                 {
7858                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7859                         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)
7860                         {
7861                                 out_tc[0] = DotProduct(v1, rsurface.texture->tcgen.parms);
7862                                 out_tc[1] = DotProduct(v1, rsurface.texture->tcgen.parms + 3);
7863                         }
7864                 }
7865                 rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
7866                 rsurface.texcoordtexture2f_bufferobject  = 0;
7867                 rsurface.texcoordtexture2f_bufferoffset  = 0;
7868                 break;
7869         case Q3TCGEN_ENVIRONMENT:
7870                 // make environment reflections using a spheremap
7871                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7872                 {
7873                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7874                         const float *vertex = rsurface.modelvertex3f + 3 * surface->num_firstvertex;
7875                         const float *normal = rsurface.modelnormal3f + 3 * surface->num_firstvertex;
7876                         float *out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;
7877                         for (j = 0;j < surface->num_vertices;j++, vertex += 3, normal += 3, out_tc += 2)
7878                         {
7879                                 // identical to Q3A's method, but executed in worldspace so
7880                                 // carried models can be shiny too
7881
7882                                 float viewer[3], d, reflected[3], worldreflected[3];
7883
7884                                 VectorSubtract(rsurface.localvieworigin, vertex, viewer);
7885                                 // VectorNormalize(viewer);
7886
7887                                 d = DotProduct(normal, viewer);
7888
7889                                 reflected[0] = normal[0]*2*d - viewer[0];
7890                                 reflected[1] = normal[1]*2*d - viewer[1];
7891                                 reflected[2] = normal[2]*2*d - viewer[2];
7892                                 // note: this is proportinal to viewer, so we can normalize later
7893
7894                                 Matrix4x4_Transform3x3(&rsurface.matrix, reflected, worldreflected);
7895                                 VectorNormalize(worldreflected);
7896
7897                                 // note: this sphere map only uses world x and z!
7898                                 // so positive and negative y will LOOK THE SAME.
7899                                 out_tc[0] = 0.5 + 0.5 * worldreflected[1];
7900                                 out_tc[1] = 0.5 - 0.5 * worldreflected[2];
7901                         }
7902                 }
7903                 rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
7904                 rsurface.texcoordtexture2f_bufferobject  = 0;
7905                 rsurface.texcoordtexture2f_bufferoffset  = 0;
7906                 break;
7907         }
7908         // the only tcmod that needs software vertex processing is turbulent, so
7909         // check for it here and apply the changes if needed
7910         // and we only support that as the first one
7911         // (handling a mixture of turbulent and other tcmods would be problematic
7912         //  without punting it entirely to a software path)
7913         if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
7914         {
7915                 amplitude = rsurface.texture->tcmods[0].parms[1];
7916                 animpos = rsurface.texture->tcmods[0].parms[2] + r_refdef.scene.time * rsurface.texture->tcmods[0].parms[3];
7917                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7918                 {
7919                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7920                         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)
7921                         {
7922                                 out_tc[0] = in_tc[0] + amplitude * sin(((v1[0] + v1[2]) * 1.0 / 1024.0f + animpos) * M_PI * 2);
7923                                 out_tc[1] = in_tc[1] + amplitude * sin(((v1[1]        ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
7924                         }
7925                 }
7926                 rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
7927                 rsurface.texcoordtexture2f_bufferobject  = 0;
7928                 rsurface.texcoordtexture2f_bufferoffset  = 0;
7929         }
7930         rsurface.texcoordlightmap2f              = rsurface.modeltexcoordlightmap2f;
7931         rsurface.texcoordlightmap2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
7932         rsurface.texcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
7933         R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
7934 }
7935
7936 void RSurf_DrawBatch_Simple(int texturenumsurfaces, const msurface_t **texturesurfacelist)
7937 {
7938         int i, j;
7939         const msurface_t *surface = texturesurfacelist[0];
7940         const msurface_t *surface2;
7941         int firstvertex;
7942         int endvertex;
7943         int numvertices;
7944         int numtriangles;
7945         // TODO: lock all array ranges before render, rather than on each surface
7946         if (texturenumsurfaces == 1)
7947         {
7948                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
7949                 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);
7950         }
7951         else if (r_batchmode.integer == 2)
7952         {
7953                 #define MAXBATCHTRIANGLES 4096
7954                 int batchtriangles = 0;
7955                 static int batchelements[MAXBATCHTRIANGLES*3];
7956                 for (i = 0;i < texturenumsurfaces;i = j)
7957                 {
7958                         surface = texturesurfacelist[i];
7959                         j = i + 1;
7960                         if (surface->num_triangles > MAXBATCHTRIANGLES)
7961                         {
7962                                 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);
7963                                 continue;
7964                         }
7965                         memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
7966                         batchtriangles = surface->num_triangles;
7967                         firstvertex = surface->num_firstvertex;
7968                         endvertex = surface->num_firstvertex + surface->num_vertices;
7969                         for (;j < texturenumsurfaces;j++)
7970                         {
7971                                 surface2 = texturesurfacelist[j];
7972                                 if (batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
7973                                         break;
7974                                 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
7975                                 batchtriangles += surface2->num_triangles;
7976                                 firstvertex = min(firstvertex, surface2->num_firstvertex);
7977                                 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
7978                         }
7979                         surface2 = texturesurfacelist[j-1];
7980                         numvertices = endvertex - firstvertex;
7981                         R_Mesh_Draw(firstvertex, numvertices, 0, batchtriangles, batchelements, NULL, 0, 0);
7982                 }
7983         }
7984         else if (r_batchmode.integer == 1)
7985         {
7986                 for (i = 0;i < texturenumsurfaces;i = j)
7987                 {
7988                         surface = texturesurfacelist[i];
7989                         for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
7990                                 if (texturesurfacelist[j] != surface2)
7991                                         break;
7992                         surface2 = texturesurfacelist[j-1];
7993                         numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
7994                         numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
7995                         GL_LockArrays(surface->num_firstvertex, numvertices);
7996                         R_Mesh_Draw(surface->num_firstvertex, numvertices, surface->num_firsttriangle, numtriangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
7997                 }
7998         }
7999         else
8000         {
8001                 for (i = 0;i < texturenumsurfaces;i++)
8002                 {
8003                         surface = texturesurfacelist[i];
8004                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8005                         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);
8006                 }
8007         }
8008 }
8009
8010 static void RSurf_BindLightmapForSurface(const msurface_t *surface)
8011 {
8012         switch(vid.renderpath)
8013         {
8014         case RENDERPATH_CGGL:
8015 #ifdef SUPPORTCG
8016                 if (r_cg_permutation->fp_Texture_Lightmap ) CG_BindTexture(r_cg_permutation->fp_Texture_Lightmap , R_GetTexture(surface->lightmaptexture ));CHECKCGERROR
8017                 if (r_cg_permutation->fp_Texture_Deluxemap) CG_BindTexture(r_cg_permutation->fp_Texture_Deluxemap, R_GetTexture(surface->deluxemaptexture));CHECKCGERROR
8018 #endif
8019                 break;
8020         case RENDERPATH_GL20:
8021                 if (r_glsl_permutation->loc_Texture_Lightmap  >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP , R_GetTexture(surface->lightmaptexture ));
8022                 if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(GL20TU_DELUXEMAP, R_GetTexture(surface->deluxemaptexture));
8023                 break;
8024         case RENDERPATH_GL13:
8025         case RENDERPATH_GL11:
8026                 R_Mesh_TexBind(0, R_GetTexture(surface->lightmaptexture));
8027                 break;
8028         }
8029 }
8030
8031 static void RSurf_BindReflectionForSurface(const msurface_t *surface)
8032 {
8033         // pick the closest matching water plane and bind textures
8034         int planeindex, vertexindex;
8035         float d, bestd;
8036         vec3_t vert;
8037         const float *v;
8038         r_waterstate_waterplane_t *p, *bestp;
8039         bestd = 0;
8040         bestp = NULL;
8041         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
8042         {
8043                 d = 0;
8044                 for (vertexindex = 0, v = rsurface.modelvertex3f + surface->num_firstvertex * 3;vertexindex < surface->num_vertices;vertexindex++, v += 3)
8045                 {
8046                         Matrix4x4_Transform(&rsurface.matrix, v, vert);
8047                         d += fabs(PlaneDiff(vert, &p->plane));
8048                 }
8049                 if (bestd > d || !bestp)
8050                 {
8051                         bestd = d;
8052                         bestp = p;
8053                 }
8054         }
8055         switch(vid.renderpath)
8056         {
8057         case RENDERPATH_CGGL:
8058 #ifdef SUPPORTCG
8059                 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
8060                 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
8061 #endif
8062                 break;
8063         case RENDERPATH_GL20:
8064                 if (r_glsl_permutation->loc_Texture_Refraction >= 0) R_Mesh_TexBind(GL20TU_REFRACTION, bestp ? R_GetTexture(bestp->texture_refraction) : R_GetTexture(r_texture_black));
8065                 if (r_glsl_permutation->loc_Texture_Reflection >= 0) R_Mesh_TexBind(GL20TU_REFLECTION, bestp ? R_GetTexture(bestp->texture_reflection) : R_GetTexture(r_texture_black));
8066                 break;
8067         case RENDERPATH_GL13:
8068         case RENDERPATH_GL11:
8069                 break;
8070         }
8071 }
8072
8073 static void RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8074 {
8075         int i;
8076         const msurface_t *surface;
8077         if (r_waterstate.renderingscene)
8078                 return;
8079         for (i = 0;i < texturenumsurfaces;i++)
8080         {
8081                 surface = texturesurfacelist[i];
8082                 RSurf_BindLightmapForSurface(surface);
8083                 RSurf_BindReflectionForSurface(surface);
8084                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8085                 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);
8086         }
8087 }
8088
8089 static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8090 {
8091         int i;
8092         int j;
8093         const msurface_t *surface = texturesurfacelist[0];
8094         const msurface_t *surface2;
8095         int firstvertex;
8096         int endvertex;
8097         int numvertices;
8098         int numtriangles;
8099         if (texturenumsurfaces == 1)
8100         {
8101                 RSurf_BindLightmapForSurface(surface);
8102                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8103                 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);
8104         }
8105         else if (r_batchmode.integer == 2)
8106         {
8107 #define MAXBATCHTRIANGLES 4096
8108                 int batchtriangles = 0;
8109                 static int batchelements[MAXBATCHTRIANGLES*3];
8110                 for (i = 0;i < texturenumsurfaces;i = j)
8111                 {
8112                         surface = texturesurfacelist[i];
8113                         RSurf_BindLightmapForSurface(surface);
8114                         j = i + 1;
8115                         if (surface->num_triangles > MAXBATCHTRIANGLES)
8116                         {
8117                                 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);
8118                                 continue;
8119                         }
8120                         memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
8121                         batchtriangles = surface->num_triangles;
8122                         firstvertex = surface->num_firstvertex;
8123                         endvertex = surface->num_firstvertex + surface->num_vertices;
8124                         for (;j < texturenumsurfaces;j++)
8125                         {
8126                                 surface2 = texturesurfacelist[j];
8127                                 if (surface2->lightmaptexture != surface->lightmaptexture || batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
8128                                         break;
8129                                 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
8130                                 batchtriangles += surface2->num_triangles;
8131                                 firstvertex = min(firstvertex, surface2->num_firstvertex);
8132                                 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
8133                         }
8134                         surface2 = texturesurfacelist[j-1];
8135                         numvertices = endvertex - firstvertex;
8136                         R_Mesh_Draw(firstvertex, numvertices, 0, batchtriangles, batchelements, NULL, 0, 0);
8137                 }
8138         }
8139         else if (r_batchmode.integer == 1)
8140         {
8141 #if 0
8142                 Con_Printf("%s batch sizes ignoring lightmap:", rsurface.texture->name);
8143                 for (i = 0;i < texturenumsurfaces;i = j)
8144                 {
8145                         surface = texturesurfacelist[i];
8146                         for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
8147                                 if (texturesurfacelist[j] != surface2)
8148                                         break;
8149                         Con_Printf(" %i", j - i);
8150                 }
8151                 Con_Printf("\n");
8152                 Con_Printf("%s batch sizes honoring lightmap:", rsurface.texture->name);
8153 #endif
8154                 for (i = 0;i < texturenumsurfaces;i = j)
8155                 {
8156                         surface = texturesurfacelist[i];
8157                         RSurf_BindLightmapForSurface(surface);
8158                         for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
8159                                 if (texturesurfacelist[j] != surface2 || texturesurfacelist[j]->lightmaptexture != surface->lightmaptexture)
8160                                         break;
8161 #if 0
8162                         Con_Printf(" %i", j - i);
8163 #endif
8164                         surface2 = texturesurfacelist[j-1];
8165                         numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
8166                         numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
8167                         GL_LockArrays(surface->num_firstvertex, numvertices);
8168                         R_Mesh_Draw(surface->num_firstvertex, numvertices, surface->num_firsttriangle, numtriangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8169                 }
8170 #if 0
8171                 Con_Printf("\n");
8172 #endif
8173         }
8174         else
8175         {
8176                 for (i = 0;i < texturenumsurfaces;i++)
8177                 {
8178                         surface = texturesurfacelist[i];
8179                         RSurf_BindLightmapForSurface(surface);
8180                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8181                         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);
8182                 }
8183         }
8184 }
8185
8186 static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8187 {
8188         int j;
8189         int texturesurfaceindex;
8190         if (r_showsurfaces.integer == 2)
8191         {
8192                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8193                 {
8194                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8195                         for (j = 0;j < surface->num_triangles;j++)
8196                         {
8197                                 float f = ((j + surface->num_firsttriangle) & 31) * (1.0f / 31.0f) * r_refdef.view.colorscale;
8198                                 GL_Color(f, f, f, 1);
8199                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle + j, 1, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8200                         }
8201                 }
8202         }
8203         else
8204         {
8205                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8206                 {
8207                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8208                         int k = (int)(((size_t)surface) / sizeof(msurface_t));
8209                         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);
8210                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8211                         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);
8212                 }
8213         }
8214 }
8215
8216 static void RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8217 {
8218         int texturesurfaceindex;
8219         int i;
8220         const float *v;
8221         float *c2;
8222         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8223         {
8224                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8225                 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)
8226                 {
8227                         c2[0] = 0.5;
8228                         c2[1] = 0.5;
8229                         c2[2] = 0.5;
8230                         c2[3] = 1;
8231                 }
8232         }
8233         rsurface.lightmapcolor4f = rsurface.array_color4f;
8234         rsurface.lightmapcolor4f_bufferobject = 0;
8235         rsurface.lightmapcolor4f_bufferoffset = 0;
8236 }
8237
8238 static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8239 {
8240         int texturesurfaceindex;
8241         int i;
8242         float f;
8243         const float *v;
8244         const float *c;
8245         float *c2;
8246         if (rsurface.lightmapcolor4f)
8247         {
8248                 // generate color arrays for the surfaces in this list
8249                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8250                 {
8251                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8252                         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)
8253                         {
8254                                 f = RSurf_FogVertex(v);
8255                                 c2[0] = c[0] * f;
8256                                 c2[1] = c[1] * f;
8257                                 c2[2] = c[2] * f;
8258                                 c2[3] = c[3];
8259                         }
8260                 }
8261         }
8262         else
8263         {
8264                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8265                 {
8266                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8267                         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)
8268                         {
8269                                 f = RSurf_FogVertex(v);
8270                                 c2[0] = f;
8271                                 c2[1] = f;
8272                                 c2[2] = f;
8273                                 c2[3] = 1;
8274                         }
8275                 }
8276         }
8277         rsurface.lightmapcolor4f = rsurface.array_color4f;
8278         rsurface.lightmapcolor4f_bufferobject = 0;
8279         rsurface.lightmapcolor4f_bufferoffset = 0;
8280 }
8281
8282 static void RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8283 {
8284         int texturesurfaceindex;
8285         int i;
8286         float f;
8287         const float *v;
8288         const float *c;
8289         float *c2;
8290         if (!rsurface.lightmapcolor4f)
8291                 return;
8292         // generate color arrays for the surfaces in this list
8293         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8294         {
8295                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8296                 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)
8297                 {
8298                         f = RSurf_FogVertex(v);
8299                         c2[0] = c[0] * f + r_refdef.fogcolor[0] * (1 - f);
8300                         c2[1] = c[1] * f + r_refdef.fogcolor[1] * (1 - f);
8301                         c2[2] = c[2] * f + r_refdef.fogcolor[2] * (1 - f);
8302                         c2[3] = c[3];
8303                 }
8304         }
8305         rsurface.lightmapcolor4f = rsurface.array_color4f;
8306         rsurface.lightmapcolor4f_bufferobject = 0;
8307         rsurface.lightmapcolor4f_bufferoffset = 0;
8308 }
8309
8310 static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a)
8311 {
8312         int texturesurfaceindex;
8313         int i;
8314         const float *c;
8315         float *c2;
8316         if (!rsurface.lightmapcolor4f)
8317                 return;
8318         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8319         {
8320                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8321                 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)
8322                 {
8323                         c2[0] = c[0] * r;
8324                         c2[1] = c[1] * g;
8325                         c2[2] = c[2] * b;
8326                         c2[3] = c[3] * a;
8327                 }
8328         }
8329         rsurface.lightmapcolor4f = rsurface.array_color4f;
8330         rsurface.lightmapcolor4f_bufferobject = 0;
8331         rsurface.lightmapcolor4f_bufferoffset = 0;
8332 }
8333
8334 static void RSurf_DrawBatch_GL11_ApplyAmbient(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8335 {
8336         int texturesurfaceindex;
8337         int i;
8338         const float *c;
8339         float *c2;
8340         if (!rsurface.lightmapcolor4f)
8341                 return;
8342         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8343         {
8344                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8345                 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)
8346                 {
8347                         c2[0] = c[0] + r_refdef.scene.ambient;
8348                         c2[1] = c[1] + r_refdef.scene.ambient;
8349                         c2[2] = c[2] + r_refdef.scene.ambient;
8350                         c2[3] = c[3];
8351                 }
8352         }
8353         rsurface.lightmapcolor4f = rsurface.array_color4f;
8354         rsurface.lightmapcolor4f_bufferobject = 0;
8355         rsurface.lightmapcolor4f_bufferoffset = 0;
8356 }
8357
8358 static void RSurf_DrawBatch_GL11_Lightmap(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
8359 {
8360         // TODO: optimize
8361         rsurface.lightmapcolor4f = NULL;
8362         rsurface.lightmapcolor4f_bufferobject = 0;
8363         rsurface.lightmapcolor4f_bufferoffset = 0;
8364         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
8365         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
8366         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
8367         GL_Color(r, g, b, a);
8368         RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist);
8369 }
8370
8371 static void RSurf_DrawBatch_GL11_Unlit(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
8372 {
8373         // TODO: optimize applyfog && applycolor case
8374         // just apply fog if necessary, and tint the fog color array if necessary
8375         rsurface.lightmapcolor4f = NULL;
8376         rsurface.lightmapcolor4f_bufferobject = 0;
8377         rsurface.lightmapcolor4f_bufferoffset = 0;
8378         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
8379         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
8380         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
8381         GL_Color(r, g, b, a);
8382         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8383 }
8384
8385 static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
8386 {
8387         int texturesurfaceindex;
8388         int i;
8389         float *c;
8390         // TODO: optimize
8391         if (texturesurfacelist[0]->lightmapinfo)
8392         {
8393                 // generate color arrays for the surfaces in this list
8394                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8395                 {
8396                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8397                         for (i = 0, c = rsurface.array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
8398                         {
8399                                 if (surface->lightmapinfo->samples)
8400                                 {
8401                                         const unsigned char *lm = surface->lightmapinfo->samples + (rsurface.modellightmapoffsets + surface->num_firstvertex)[i];
8402                                         float scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
8403                                         VectorScale(lm, scale, c);
8404                                         if (surface->lightmapinfo->styles[1] != 255)
8405                                         {
8406                                                 int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
8407                                                 lm += size3;
8408                                                 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
8409                                                 VectorMA(c, scale, lm, c);
8410                                                 if (surface->lightmapinfo->styles[2] != 255)
8411                                                 {
8412                                                         lm += size3;
8413                                                         scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
8414                                                         VectorMA(c, scale, lm, c);
8415                                                         if (surface->lightmapinfo->styles[3] != 255)
8416                                                         {
8417                                                                 lm += size3;
8418                                                                 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
8419                                                                 VectorMA(c, scale, lm, c);
8420                                                         }
8421                                                 }
8422                                         }
8423                                 }
8424                                 else
8425                                         VectorClear(c);
8426                                 c[3] = 1;
8427                         }
8428                 }
8429                 rsurface.lightmapcolor4f = rsurface.array_color4f;
8430                 rsurface.lightmapcolor4f_bufferobject = 0;
8431                 rsurface.lightmapcolor4f_bufferoffset = 0;
8432         }
8433         else
8434         {
8435                 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
8436                 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
8437                 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
8438         }
8439         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
8440         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
8441         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
8442         GL_Color(r, g, b, a);
8443         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8444 }
8445
8446 static void RSurf_DrawBatch_GL11_ApplyVertexShade(int texturenumsurfaces, const msurface_t **texturesurfacelist, float *r, float *g, float *b, float *a, qboolean *applycolor)
8447 {
8448         int texturesurfaceindex;
8449         int i;
8450         float f;
8451         float alpha;
8452         const float *v;
8453         const float *n;
8454         float *c;
8455         vec3_t ambientcolor;
8456         vec3_t diffusecolor;
8457         vec3_t lightdir;
8458         // TODO: optimize
8459         // model lighting
8460         VectorCopy(rsurface.modellight_lightdir, lightdir);
8461         f = 0.5f * r_refdef.lightmapintensity;
8462         ambientcolor[0] = rsurface.modellight_ambient[0] * *r * f;
8463         ambientcolor[1] = rsurface.modellight_ambient[1] * *g * f;
8464         ambientcolor[2] = rsurface.modellight_ambient[2] * *b * f;
8465         diffusecolor[0] = rsurface.modellight_diffuse[0] * *r * f;
8466         diffusecolor[1] = rsurface.modellight_diffuse[1] * *g * f;
8467         diffusecolor[2] = rsurface.modellight_diffuse[2] * *b * f;
8468         alpha = *a;
8469         if (VectorLength2(diffusecolor) > 0 && rsurface.normal3f)
8470         {
8471                 // generate color arrays for the surfaces in this list
8472                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8473                 {
8474                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8475                         int numverts = surface->num_vertices;
8476                         v = rsurface.vertex3f + 3 * surface->num_firstvertex;
8477                         n = rsurface.normal3f + 3 * surface->num_firstvertex;
8478                         c = rsurface.array_color4f + 4 * surface->num_firstvertex;
8479                         // q3-style directional shading
8480                         for (i = 0;i < numverts;i++, v += 3, n += 3, c += 4)
8481                         {
8482                                 if ((f = DotProduct(n, lightdir)) > 0)
8483                                         VectorMA(ambientcolor, f, diffusecolor, c);
8484                                 else
8485                                         VectorCopy(ambientcolor, c);
8486                                 c[3] = alpha;
8487                         }
8488                 }
8489                 *r = 1;
8490                 *g = 1;
8491                 *b = 1;
8492                 *a = 1;
8493                 rsurface.lightmapcolor4f = rsurface.array_color4f;
8494                 rsurface.lightmapcolor4f_bufferobject = 0;
8495                 rsurface.lightmapcolor4f_bufferoffset = 0;
8496                 *applycolor = false;
8497         }
8498         else
8499         {
8500                 *r = ambientcolor[0];
8501                 *g = ambientcolor[1];
8502                 *b = ambientcolor[2];
8503                 rsurface.lightmapcolor4f = NULL;
8504                 rsurface.lightmapcolor4f_bufferobject = 0;
8505                 rsurface.lightmapcolor4f_bufferoffset = 0;
8506         }
8507 }
8508
8509 static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
8510 {
8511         RSurf_DrawBatch_GL11_ApplyVertexShade(texturenumsurfaces, texturesurfacelist, &r, &g, &b, &a, &applycolor);
8512         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
8513         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
8514         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
8515         GL_Color(r, g, b, a);
8516         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8517 }
8518
8519 void RSurf_SetupDepthAndCulling(void)
8520 {
8521         // submodels are biased to avoid z-fighting with world surfaces that they
8522         // may be exactly overlapping (avoids z-fighting artifacts on certain
8523         // doors and things in Quake maps)
8524         GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
8525         GL_PolygonOffset(rsurface.basepolygonfactor + rsurface.texture->biaspolygonfactor, rsurface.basepolygonoffset + rsurface.texture->biaspolygonoffset);
8526         GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
8527         GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_refdef.view.cullface_back);
8528 }
8529
8530 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8531 {
8532         // transparent sky would be ridiculous
8533         if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
8534                 return;
8535         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8536         skyrenderlater = true;
8537         RSurf_SetupDepthAndCulling();
8538         GL_DepthMask(true);
8539         // LordHavoc: HalfLife maps have freaky skypolys so don't use
8540         // skymasking on them, and Quake3 never did sky masking (unlike
8541         // software Quake and software Quake2), so disable the sky masking
8542         // in Quake3 maps as it causes problems with q3map2 sky tricks,
8543         // and skymasking also looks very bad when noclipping outside the
8544         // level, so don't use it then either.
8545         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_refdef.viewcache.world_novis)
8546         {
8547                 GL_Color(r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], 1);
8548                 R_Mesh_ColorPointer(NULL, 0, 0);
8549                 R_Mesh_ResetTextureState();
8550                 if (skyrendermasked)
8551                 {
8552                         R_SetupShader_DepthOrShadow();
8553                         // depth-only (masking)
8554                         GL_ColorMask(0,0,0,0);
8555                         // just to make sure that braindead drivers don't draw
8556                         // anything despite that colormask...
8557                         GL_BlendFunc(GL_ZERO, GL_ONE);
8558                 }
8559                 else
8560                 {
8561                         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8562                         // fog sky
8563                         GL_BlendFunc(GL_ONE, GL_ZERO);
8564                 }
8565                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
8566                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8567                 if (skyrendermasked)
8568                         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
8569         }
8570         R_Mesh_ResetTextureState();
8571         GL_Color(1, 1, 1, 1);
8572 }
8573
8574 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
8575 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
8576 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
8577 {
8578         qboolean reflect = (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)) && !prepass;
8579         qboolean refract = (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION)) && !prepass;
8580
8581         if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION)))
8582                 return;
8583
8584         if ((rsurface.uselightmaptexture || (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND))
8585                 R_Mesh_ColorPointer(NULL, 0, 0);
8586         else
8587                 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
8588
8589         if (refract)
8590         {
8591                 // render background
8592                 GL_BlendFunc(GL_ONE, GL_ZERO);
8593                 GL_DepthMask(true);
8594                 GL_AlphaTest(false);
8595
8596                 GL_Color(1, 1, 1, 1);
8597                 R_Mesh_ColorPointer(NULL, 0, 0);
8598
8599                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND);
8600                 RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
8601                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8602                 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
8603                 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
8604                 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
8605                 R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
8606                 RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist);
8607                 GL_LockArrays(0, 0);
8608
8609                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
8610                 GL_DepthMask(false);
8611                 if ((rsurface.uselightmaptexture || (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND))
8612                         R_Mesh_ColorPointer(NULL, 0, 0);
8613                 else
8614                         R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
8615         }
8616
8617         R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, prepass ? RSURFPASS_DEFERREDGEOMETRY : RSURFPASS_BASE);
8618
8619         RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
8620         R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8621         R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
8622         R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
8623         R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
8624         if (!prepass)
8625                 R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
8626
8627         if (refract)
8628         {
8629                 GL_BlendFunc(GL_ONE, GL_ZERO);
8630                 GL_DepthMask(true);
8631                 GL_AlphaTest(false);
8632         }
8633         else
8634         {
8635                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
8636                 GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
8637                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0 && !r_shadow_usingdeferredprepass);
8638         }
8639
8640         if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
8641         {
8642                 if (refract || reflect)
8643                         RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist);
8644                 else
8645                         RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist);
8646         }
8647         else
8648         {
8649                 if (refract || reflect)
8650                         RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist);
8651                 else
8652                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8653         }
8654         GL_LockArrays(0, 0);
8655 }
8656
8657 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
8658 {
8659         // OpenGL 1.3 path - anything not completely ancient
8660         int texturesurfaceindex;
8661         qboolean applycolor;
8662         qboolean applyfog;
8663         int layerindex;
8664         const texturelayer_t *layer;
8665         RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
8666
8667         for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
8668         {
8669                 vec4_t layercolor;
8670                 int layertexrgbscale;
8671                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8672                 {
8673                         if (layerindex == 0)
8674                                 GL_AlphaTest(true);
8675                         else
8676                         {
8677                                 GL_AlphaTest(false);
8678                                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
8679                         }
8680                 }
8681                 GL_DepthMask(layer->depthmask && writedepth);
8682                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
8683                 if (layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2)
8684                 {
8685                         layertexrgbscale = 4;
8686                         VectorScale(layer->color, 0.25f, layercolor);
8687                 }
8688                 else if (layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1)
8689                 {
8690                         layertexrgbscale = 2;
8691                         VectorScale(layer->color, 0.5f, layercolor);
8692                 }
8693                 else
8694                 {
8695                         layertexrgbscale = 1;
8696                         VectorScale(layer->color, 1.0f, layercolor);
8697                 }
8698                 layercolor[3] = layer->color[3];
8699                 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
8700                 R_Mesh_ColorPointer(NULL, 0, 0);
8701                 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
8702                 switch (layer->type)
8703                 {
8704                 case TEXTURELAYERTYPE_LITTEXTURE:
8705                         // single-pass lightmapped texture with 2x rgbscale
8706                         //R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
8707                         R_Mesh_TexMatrix(0, NULL);
8708                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8709                         R_Mesh_TexCoordPointer(0, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
8710                         R_Mesh_TexBind(1, R_GetTexture(layer->texture));
8711                         R_Mesh_TexMatrix(1, &layer->texmatrix);
8712                         R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
8713                         R_Mesh_TexCoordPointer(1, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8714                         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
8715                                 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
8716                         else if (rsurface.uselightmaptexture)
8717                                 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
8718                         else
8719                                 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
8720                         break;
8721                 case TEXTURELAYERTYPE_TEXTURE:
8722                         // singletexture unlit texture with transparency support
8723                         R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8724                         R_Mesh_TexMatrix(0, &layer->texmatrix);
8725                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
8726                         R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8727                         R_Mesh_TexBind(1, 0);
8728                         R_Mesh_TexCoordPointer(1, 2, NULL, 0, 0);
8729                         RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
8730                         break;
8731                 case TEXTURELAYERTYPE_FOG:
8732                         // singletexture fogging
8733                         if (layer->texture)
8734                         {
8735                                 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8736                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
8737                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
8738                                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8739                         }
8740                         else
8741                         {
8742                                 R_Mesh_TexBind(0, 0);
8743                                 R_Mesh_TexCoordPointer(0, 2, NULL, 0, 0);
8744                         }
8745                         R_Mesh_TexBind(1, 0);
8746                         R_Mesh_TexCoordPointer(1, 2, NULL, 0, 0);
8747                         // generate a color array for the fog pass
8748                         R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
8749                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8750                         {
8751                                 int i;
8752                                 float f;
8753                                 const float *v;
8754                                 float *c;
8755                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8756                                 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)
8757                                 {
8758                                         f = 1 - RSurf_FogVertex(v);
8759                                         c[0] = layercolor[0];
8760                                         c[1] = layercolor[1];
8761                                         c[2] = layercolor[2];
8762                                         c[3] = f * layercolor[3];
8763                                 }
8764                         }
8765                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8766                         break;
8767                 default:
8768                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
8769                 }
8770                 GL_LockArrays(0, 0);
8771         }
8772         CHECKGLERROR
8773         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8774         {
8775                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
8776                 GL_AlphaTest(false);
8777         }
8778 }
8779
8780 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
8781 {
8782         // OpenGL 1.1 - crusty old voodoo path
8783         int texturesurfaceindex;
8784         qboolean applyfog;
8785         int layerindex;
8786         const texturelayer_t *layer;
8787         RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
8788
8789         for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
8790         {
8791                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8792                 {
8793                         if (layerindex == 0)
8794                                 GL_AlphaTest(true);
8795                         else
8796                         {
8797                                 GL_AlphaTest(false);
8798                                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
8799                         }
8800                 }
8801                 GL_DepthMask(layer->depthmask && writedepth);
8802                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
8803                 R_Mesh_ColorPointer(NULL, 0, 0);
8804                 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
8805                 switch (layer->type)
8806                 {
8807                 case TEXTURELAYERTYPE_LITTEXTURE:
8808                         if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
8809                         {
8810                                 // two-pass lit texture with 2x rgbscale
8811                                 // first the lightmap pass
8812                                 //R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
8813                                 R_Mesh_TexMatrix(0, NULL);
8814                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8815                                 R_Mesh_TexCoordPointer(0, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
8816                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
8817                                         RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
8818                                 else if (rsurface.uselightmaptexture)
8819                                         RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
8820                                 else
8821                                         RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
8822                                 GL_LockArrays(0, 0);
8823                                 // then apply the texture to it
8824                                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
8825                                 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8826                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
8827                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8828                                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8829                                 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);
8830                         }
8831                         else
8832                         {
8833                                 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
8834                                 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8835                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
8836                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8837                                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8838                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
8839                                         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);
8840                                 else
8841                                         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);
8842                         }
8843                         break;
8844                 case TEXTURELAYERTYPE_TEXTURE:
8845                         // singletexture unlit texture with transparency support
8846                         R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8847                         R_Mesh_TexMatrix(0, &layer->texmatrix);
8848                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8849                         R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8850                         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);
8851                         break;
8852                 case TEXTURELAYERTYPE_FOG:
8853                         // singletexture fogging
8854                         if (layer->texture)
8855                         {
8856                                 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8857                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
8858                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8859                                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8860                         }
8861                         else
8862                         {
8863                                 R_Mesh_TexBind(0, 0);
8864                                 R_Mesh_TexCoordPointer(0, 2, NULL, 0, 0);
8865                         }
8866                         // generate a color array for the fog pass
8867                         R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
8868                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8869                         {
8870                                 int i;
8871                                 float f;
8872                                 const float *v;
8873                                 float *c;
8874                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8875                                 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)
8876                                 {
8877                                         f = 1 - RSurf_FogVertex(v);
8878                                         c[0] = layer->color[0];
8879                                         c[1] = layer->color[1];
8880                                         c[2] = layer->color[2];
8881                                         c[3] = f * layer->color[3];
8882                                 }
8883                         }
8884                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8885                         break;
8886                 default:
8887                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
8888                 }
8889                 GL_LockArrays(0, 0);
8890         }
8891         CHECKGLERROR
8892         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8893         {
8894                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
8895                 GL_AlphaTest(false);
8896         }
8897 }
8898
8899 static void R_DrawTextureSurfaceList_ShowSurfaces3(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
8900 {
8901         float c[4];
8902
8903         GL_AlphaTest(false);
8904         R_Mesh_ColorPointer(NULL, 0, 0);
8905         R_Mesh_ResetTextureState();
8906         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8907
8908         if(rsurface.texture && rsurface.texture->currentskinframe)
8909         {
8910                 memcpy(c, rsurface.texture->currentskinframe->avgcolor, sizeof(c));
8911                 c[3] *= rsurface.texture->currentalpha;
8912         }
8913         else
8914         {
8915                 c[0] = 1;
8916                 c[1] = 0;
8917                 c[2] = 1;
8918                 c[3] = 1;
8919         }
8920
8921         if (rsurface.texture->pantstexture || rsurface.texture->shirttexture)
8922         {
8923                 c[0] = 0.5 * (rsurface.colormap_pantscolor[0] * 0.3 + rsurface.colormap_shirtcolor[0] * 0.7);
8924                 c[1] = 0.5 * (rsurface.colormap_pantscolor[1] * 0.3 + rsurface.colormap_shirtcolor[1] * 0.7);
8925                 c[2] = 0.5 * (rsurface.colormap_pantscolor[2] * 0.3 + rsurface.colormap_shirtcolor[2] * 0.7);
8926         }
8927
8928         // brighten it up (as texture value 127 means "unlit")
8929         c[0] *= 2 * r_refdef.view.colorscale;
8930         c[1] *= 2 * r_refdef.view.colorscale;
8931         c[2] *= 2 * r_refdef.view.colorscale;
8932
8933         if(rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERALPHA)
8934                 c[3] *= r_wateralpha.value;
8935
8936         if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHA && c[3] != 1)
8937         {
8938                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
8939                 GL_DepthMask(false);
8940         }
8941         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
8942         {
8943                 GL_BlendFunc(GL_ONE, GL_ONE);
8944                 GL_DepthMask(false);
8945         }
8946         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8947         {
8948                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // can't do alpha test without texture, so let's blend instead
8949                 GL_DepthMask(false);
8950         }
8951         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
8952         {
8953                 GL_BlendFunc(rsurface.texture->customblendfunc[0], rsurface.texture->customblendfunc[1]);
8954                 GL_DepthMask(false);
8955         }
8956         else
8957         {
8958                 GL_BlendFunc(GL_ONE, GL_ZERO);
8959                 GL_DepthMask(writedepth);
8960         }
8961
8962         rsurface.lightmapcolor4f = NULL;
8963
8964         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
8965         {
8966                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
8967
8968                 rsurface.lightmapcolor4f = NULL;
8969                 rsurface.lightmapcolor4f_bufferobject = 0;
8970                 rsurface.lightmapcolor4f_bufferoffset = 0;
8971         }
8972         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
8973         {
8974                 qboolean applycolor = true;
8975                 float one = 1.0;
8976
8977                 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
8978
8979                 r_refdef.lightmapintensity = 1;
8980                 RSurf_DrawBatch_GL11_ApplyVertexShade(texturenumsurfaces, texturesurfacelist, &one, &one, &one, &one, &applycolor);
8981                 r_refdef.lightmapintensity = 0; // we're in showsurfaces, after all
8982         }
8983         else
8984         {
8985                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
8986
8987                 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
8988                 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
8989                 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
8990         }
8991
8992         if(!rsurface.lightmapcolor4f)
8993                 RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(texturenumsurfaces, texturesurfacelist);
8994
8995         RSurf_DrawBatch_GL11_ApplyAmbient(texturenumsurfaces, texturesurfacelist);
8996         RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, c[0], c[1], c[2], c[3]);
8997         if(r_refdef.fogenabled)
8998                 RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(texturenumsurfaces, texturesurfacelist);
8999
9000         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
9001         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9002 }
9003
9004 static void R_DrawWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
9005 {
9006         CHECKGLERROR
9007         RSurf_SetupDepthAndCulling();
9008         if (r_showsurfaces.integer == 3 && !prepass)
9009         {
9010                 R_DrawTextureSurfaceList_ShowSurfaces3(texturenumsurfaces, texturesurfacelist, writedepth);
9011                 return;
9012         }
9013         switch (vid.renderpath)
9014         {
9015         case RENDERPATH_GL20:
9016         case RENDERPATH_CGGL:
9017                 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
9018                 break;
9019         case RENDERPATH_GL13:
9020                 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
9021                 break;
9022         case RENDERPATH_GL11:
9023                 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
9024                 break;
9025         }
9026         CHECKGLERROR
9027 }
9028
9029 static void R_DrawModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
9030 {
9031         CHECKGLERROR
9032         RSurf_SetupDepthAndCulling();
9033         if (r_showsurfaces.integer == 3 && !prepass)
9034         {
9035                 R_DrawTextureSurfaceList_ShowSurfaces3(texturenumsurfaces, texturesurfacelist, writedepth);
9036                 return;
9037         }
9038         switch (vid.renderpath)
9039         {
9040         case RENDERPATH_GL20:
9041         case RENDERPATH_CGGL:
9042                 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
9043                 break;
9044         case RENDERPATH_GL13:
9045                 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
9046                 break;
9047         case RENDERPATH_GL11:
9048                 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
9049                 break;
9050         }
9051         CHECKGLERROR
9052 }
9053
9054 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
9055 {
9056         int i, j;
9057         int texturenumsurfaces, endsurface;
9058         texture_t *texture;
9059         const msurface_t *surface;
9060         const msurface_t *texturesurfacelist[256];
9061
9062         // if the model is static it doesn't matter what value we give for
9063         // wantnormals and wanttangents, so this logic uses only rules applicable
9064         // to a model, knowing that they are meaningless otherwise
9065         if (ent == r_refdef.scene.worldentity)
9066                 RSurf_ActiveWorldEntity();
9067         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
9068                 RSurf_ActiveModelEntity(ent, false, false, false);
9069         else
9070         {
9071                 switch (vid.renderpath)
9072                 {
9073                 case RENDERPATH_GL20:
9074                 case RENDERPATH_CGGL:
9075                         RSurf_ActiveModelEntity(ent, true, true, false);
9076                         break;
9077                 case RENDERPATH_GL13:
9078                 case RENDERPATH_GL11:
9079                         RSurf_ActiveModelEntity(ent, true, false, false);
9080                         break;
9081                 }
9082         }
9083
9084         if (r_transparentdepthmasking.integer)
9085         {
9086                 qboolean setup = false;
9087                 for (i = 0;i < numsurfaces;i = j)
9088                 {
9089                         j = i + 1;
9090                         surface = rsurface.modelsurfaces + surfacelist[i];
9091                         texture = surface->texture;
9092                         rsurface.texture = R_GetCurrentTexture(texture);
9093                         rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
9094                         // scan ahead until we find a different texture
9095                         endsurface = min(i + 1024, numsurfaces);
9096                         texturenumsurfaces = 0;
9097                         texturesurfacelist[texturenumsurfaces++] = surface;
9098                         for (;j < endsurface;j++)
9099                         {
9100                                 surface = rsurface.modelsurfaces + surfacelist[j];
9101                                 if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
9102                                         break;
9103                                 texturesurfacelist[texturenumsurfaces++] = surface;
9104                         }
9105                         if (!(rsurface.texture->currentmaterialflags & MATERIALFLAG_TRANSDEPTH))
9106                                 continue;
9107                         // render the range of surfaces as depth
9108                         if (!setup)
9109                         {
9110                                 setup = true;
9111                                 GL_ColorMask(0,0,0,0);
9112                                 GL_Color(1,1,1,1);
9113                                 GL_DepthTest(true);
9114                                 GL_BlendFunc(GL_ONE, GL_ZERO);
9115                                 GL_DepthMask(true);
9116                                 GL_AlphaTest(false);
9117                                 R_Mesh_ColorPointer(NULL, 0, 0);
9118                                 R_Mesh_ResetTextureState();
9119                                 R_SetupShader_DepthOrShadow();
9120                         }
9121                         RSurf_SetupDepthAndCulling();
9122                         RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9123                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9124                 }
9125                 if (setup)
9126                         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
9127         }
9128
9129         for (i = 0;i < numsurfaces;i = j)
9130         {
9131                 j = i + 1;
9132                 surface = rsurface.modelsurfaces + surfacelist[i];
9133                 texture = surface->texture;
9134                 rsurface.texture = R_GetCurrentTexture(texture);
9135                 rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
9136                 // scan ahead until we find a different texture
9137                 endsurface = min(i + 1024, numsurfaces);
9138                 texturenumsurfaces = 0;
9139                 texturesurfacelist[texturenumsurfaces++] = surface;
9140                 for (;j < endsurface;j++)
9141                 {
9142                         surface = rsurface.modelsurfaces + surfacelist[j];
9143                         if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
9144                                 break;
9145                         texturesurfacelist[texturenumsurfaces++] = surface;
9146                 }
9147                 // render the range of surfaces
9148                 if (ent == r_refdef.scene.worldentity)
9149                         R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
9150                 else
9151                         R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
9152         }
9153         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
9154         GL_AlphaTest(false);
9155 }
9156
9157 static void R_ProcessTransparentTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, const entity_render_t *queueentity)
9158 {
9159         // transparent surfaces get pushed off into the transparent queue
9160         int surfacelistindex;
9161         const msurface_t *surface;
9162         vec3_t tempcenter, center;
9163         for (surfacelistindex = 0;surfacelistindex < texturenumsurfaces;surfacelistindex++)
9164         {
9165                 surface = texturesurfacelist[surfacelistindex];
9166                 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
9167                 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
9168                 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
9169                 Matrix4x4_Transform(&rsurface.matrix, tempcenter, center);
9170                 if (queueentity->transparent_offset) // transparent offset
9171                 {
9172                         center[0] += r_refdef.view.forward[0]*queueentity->transparent_offset;
9173                         center[1] += r_refdef.view.forward[1]*queueentity->transparent_offset;
9174                         center[2] += r_refdef.view.forward[2]*queueentity->transparent_offset;
9175                 }
9176                 R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_refdef.view.origin : center, R_DrawSurface_TransparentCallback, queueentity, surface - rsurface.modelsurfaces, rsurface.rtlight);
9177         }
9178 }
9179
9180 static void R_ProcessWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, qboolean prepass)
9181 {
9182         const entity_render_t *queueentity = r_refdef.scene.worldentity;
9183         CHECKGLERROR
9184         if (depthonly)
9185         {
9186                 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
9187                         return;
9188                 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
9189                         return;
9190                 RSurf_SetupDepthAndCulling();
9191                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9192                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9193         }
9194         else if (prepass)
9195         {
9196                 if (!rsurface.texture->currentnumlayers)
9197                         return;
9198                 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
9199                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
9200                 else
9201                         R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
9202         }
9203         else if (r_showsurfaces.integer && !r_refdef.view.showdebug && !prepass)
9204         {
9205                 RSurf_SetupDepthAndCulling();
9206                 GL_AlphaTest(false);
9207                 R_Mesh_ColorPointer(NULL, 0, 0);
9208                 R_Mesh_ResetTextureState();
9209                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9210                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9211                 GL_DepthMask(true);
9212                 GL_BlendFunc(GL_ONE, GL_ZERO);
9213                 GL_Color(0, 0, 0, 1);
9214                 GL_DepthTest(writedepth);
9215                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9216         }
9217         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3 && !prepass)
9218         {
9219                 RSurf_SetupDepthAndCulling();
9220                 GL_AlphaTest(false);
9221                 R_Mesh_ColorPointer(NULL, 0, 0);
9222                 R_Mesh_ResetTextureState();
9223                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9224                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9225                 GL_DepthMask(true);
9226                 GL_BlendFunc(GL_ONE, GL_ZERO);
9227                 GL_DepthTest(true);
9228                 RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
9229         }
9230         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
9231                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
9232         else if (!rsurface.texture->currentnumlayers)
9233                 return;
9234         else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
9235         {
9236                 // in the deferred case, transparent surfaces were queued during prepass
9237                 if (!r_shadow_usingdeferredprepass)
9238                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
9239         }
9240         else
9241         {
9242                 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
9243                 R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
9244         }
9245         CHECKGLERROR
9246 }
9247
9248 void R_QueueWorldSurfaceList(int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
9249 {
9250         int i, j;
9251         texture_t *texture;
9252         // break the surface list down into batches by texture and use of lightmapping
9253         for (i = 0;i < numsurfaces;i = j)
9254         {
9255                 j = i + 1;
9256                 // texture is the base texture pointer, rsurface.texture is the
9257                 // current frame/skin the texture is directing us to use (for example
9258                 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
9259                 // use skin 1 instead)
9260                 texture = surfacelist[i]->texture;
9261                 rsurface.texture = R_GetCurrentTexture(texture);
9262                 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL && !depthonly && !prepass;
9263                 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
9264                 {
9265                         // if this texture is not the kind we want, skip ahead to the next one
9266                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
9267                                 ;
9268                         continue;
9269                 }
9270                 // simply scan ahead until we find a different texture or lightmap state
9271                 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
9272                         ;
9273                 // render the range of surfaces
9274                 R_ProcessWorldTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, prepass);
9275         }
9276 }
9277
9278 static void R_ProcessModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, const entity_render_t *queueentity, qboolean prepass)
9279 {
9280         CHECKGLERROR
9281         if (depthonly)
9282         {
9283                 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
9284                         return;
9285                 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
9286                         return;
9287                 RSurf_SetupDepthAndCulling();
9288                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9289                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9290         }
9291         else if (prepass)
9292         {
9293                 if (!rsurface.texture->currentnumlayers)
9294                         return;
9295                 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
9296                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
9297                 else
9298                         R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
9299         }
9300         else if (r_showsurfaces.integer && !r_refdef.view.showdebug)
9301         {
9302                 RSurf_SetupDepthAndCulling();
9303                 GL_AlphaTest(false);
9304                 R_Mesh_ColorPointer(NULL, 0, 0);
9305                 R_Mesh_ResetTextureState();
9306                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9307                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9308                 GL_DepthMask(true);
9309                 GL_BlendFunc(GL_ONE, GL_ZERO);
9310                 GL_Color(0, 0, 0, 1);
9311                 GL_DepthTest(writedepth);
9312                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9313         }
9314         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
9315         {
9316                 RSurf_SetupDepthAndCulling();
9317                 GL_AlphaTest(false);
9318                 R_Mesh_ColorPointer(NULL, 0, 0);
9319                 R_Mesh_ResetTextureState();
9320                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9321                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9322                 GL_DepthMask(true);
9323                 GL_BlendFunc(GL_ONE, GL_ZERO);
9324                 GL_DepthTest(true);
9325                 RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
9326         }
9327         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
9328                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
9329         else if (!rsurface.texture->currentnumlayers)
9330                 return;
9331         else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
9332         {
9333                 // in the deferred case, transparent surfaces were queued during prepass
9334                 if (!r_shadow_usingdeferredprepass)
9335                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
9336         }
9337         else
9338         {
9339                 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
9340                 R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
9341         }
9342         CHECKGLERROR
9343 }
9344
9345 void R_QueueModelSurfaceList(entity_render_t *ent, int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
9346 {
9347         int i, j;
9348         texture_t *texture;
9349         // break the surface list down into batches by texture and use of lightmapping
9350         for (i = 0;i < numsurfaces;i = j)
9351         {
9352                 j = i + 1;
9353                 // texture is the base texture pointer, rsurface.texture is the
9354                 // current frame/skin the texture is directing us to use (for example
9355                 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
9356                 // use skin 1 instead)
9357                 texture = surfacelist[i]->texture;
9358                 rsurface.texture = R_GetCurrentTexture(texture);
9359                 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL && !depthonly && !prepass;
9360                 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
9361                 {
9362                         // if this texture is not the kind we want, skip ahead to the next one
9363                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
9364                                 ;
9365                         continue;
9366                 }
9367                 // simply scan ahead until we find a different texture or lightmap state
9368                 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
9369                         ;
9370                 // render the range of surfaces
9371                 R_ProcessModelTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, ent, prepass);
9372         }
9373 }
9374
9375 float locboxvertex3f[6*4*3] =
9376 {
9377         1,0,1, 1,0,0, 1,1,0, 1,1,1,
9378         0,1,1, 0,1,0, 0,0,0, 0,0,1,
9379         1,1,1, 1,1,0, 0,1,0, 0,1,1,
9380         0,0,1, 0,0,0, 1,0,0, 1,0,1,
9381         0,0,1, 1,0,1, 1,1,1, 0,1,1,
9382         1,0,0, 0,0,0, 0,1,0, 1,1,0
9383 };
9384
9385 unsigned short locboxelements[6*2*3] =
9386 {
9387          0, 1, 2, 0, 2, 3,
9388          4, 5, 6, 4, 6, 7,
9389          8, 9,10, 8,10,11,
9390         12,13,14, 12,14,15,
9391         16,17,18, 16,18,19,
9392         20,21,22, 20,22,23
9393 };
9394
9395 void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
9396 {
9397         int i, j;
9398         cl_locnode_t *loc = (cl_locnode_t *)ent;
9399         vec3_t mins, size;
9400         float vertex3f[6*4*3];
9401         CHECKGLERROR
9402         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9403         GL_DepthMask(false);
9404         GL_DepthRange(0, 1);
9405         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
9406         GL_DepthTest(true);
9407         GL_CullFace(GL_NONE);
9408         R_EntityMatrix(&identitymatrix);
9409
9410         R_Mesh_VertexPointer(vertex3f, 0, 0);
9411         R_Mesh_ColorPointer(NULL, 0, 0);
9412         R_Mesh_ResetTextureState();
9413         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9414
9415         i = surfacelist[0];
9416         GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_refdef.view.colorscale,
9417                          ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_refdef.view.colorscale,
9418                          ((i & 0x01C0) >> 6) * (1.0f / 7.0f) * r_refdef.view.colorscale,
9419                         surfacelist[0] < 0 ? 0.5f : 0.125f);
9420
9421         if (VectorCompare(loc->mins, loc->maxs))
9422         {
9423                 VectorSet(size, 2, 2, 2);
9424                 VectorMA(loc->mins, -0.5f, size, mins);
9425         }
9426         else
9427         {
9428                 VectorCopy(loc->mins, mins);
9429                 VectorSubtract(loc->maxs, loc->mins, size);
9430         }
9431
9432         for (i = 0;i < 6*4*3;)
9433                 for (j = 0;j < 3;j++, i++)
9434                         vertex3f[i] = mins[j] + size[j] * locboxvertex3f[i];
9435
9436         R_Mesh_Draw(0, 6*4, 0, 6*2, NULL, locboxelements, 0, 0);
9437 }
9438
9439 void R_DrawLocs(void)
9440 {
9441         int index;
9442         cl_locnode_t *loc, *nearestloc;
9443         vec3_t center;
9444         nearestloc = CL_Locs_FindNearest(cl.movement_origin);
9445         for (loc = cl.locnodes, index = 0;loc;loc = loc->next, index++)
9446         {
9447                 VectorLerp(loc->mins, 0.5f, loc->maxs, center);
9448                 R_MeshQueue_AddTransparent(center, R_DrawLoc_Callback, (entity_render_t *)loc, loc == nearestloc ? -1 : index, NULL);
9449         }
9450 }
9451
9452 void R_DecalSystem_Reset(decalsystem_t *decalsystem)
9453 {
9454         if (decalsystem->decals)
9455                 Mem_Free(decalsystem->decals);
9456         memset(decalsystem, 0, sizeof(*decalsystem));
9457 }
9458
9459 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)
9460 {
9461         tridecal_t *decal;
9462         tridecal_t *decals;
9463         int i;
9464         int maxdecals;
9465
9466         // expand or initialize the system
9467         if (decalsystem->maxdecals <= decalsystem->numdecals)
9468         {
9469                 decalsystem_t old = *decalsystem;
9470                 qboolean useshortelements;
9471                 decalsystem->maxdecals = max(16, decalsystem->maxdecals * 2);
9472                 useshortelements = decalsystem->maxdecals * 3 <= 65536;
9473                 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)));
9474                 decalsystem->color4f = (float *)(decalsystem->decals + decalsystem->maxdecals);
9475                 decalsystem->texcoord2f = (float *)(decalsystem->color4f + decalsystem->maxdecals*12);
9476                 decalsystem->vertex3f = (float *)(decalsystem->texcoord2f + decalsystem->maxdecals*6);
9477                 decalsystem->element3i = (int *)(decalsystem->vertex3f + decalsystem->maxdecals*9);
9478                 decalsystem->element3s = (useshortelements ? ((unsigned short *)(decalsystem->element3i + decalsystem->maxdecals*3)) : NULL);
9479                 if (decalsystem->numdecals)
9480                         memcpy(decalsystem->decals, old.decals, decalsystem->numdecals * sizeof(tridecal_t));
9481                 if (old.decals)
9482                         Mem_Free(old.decals);
9483                 for (i = 0;i < decalsystem->maxdecals*3;i++)
9484                         decalsystem->element3i[i] = i;
9485                 if (useshortelements)
9486                         for (i = 0;i < decalsystem->maxdecals*3;i++)
9487                                 decalsystem->element3s[i] = i;
9488         }
9489
9490         // grab a decal and search for another free slot for the next one
9491         maxdecals = decalsystem->maxdecals;
9492         decals = decalsystem->decals;
9493         decal = decalsystem->decals + (i = decalsystem->freedecal++);
9494         for (i = decalsystem->freedecal;i < decalsystem->numdecals && decals[i].color4ub[0][3];i++)
9495                 ;
9496         decalsystem->freedecal = i;
9497         if (decalsystem->numdecals <= i)
9498                 decalsystem->numdecals = i + 1;
9499
9500         // initialize the decal
9501         decal->lived = 0;
9502         decal->triangleindex = triangleindex;
9503         decal->surfaceindex = surfaceindex;
9504         decal->decalsequence = decalsequence;
9505         decal->color4ub[0][0] = (unsigned char)(c0[0]*255.0f);
9506         decal->color4ub[0][1] = (unsigned char)(c0[1]*255.0f);
9507         decal->color4ub[0][2] = (unsigned char)(c0[2]*255.0f);
9508         decal->color4ub[0][3] = 255;
9509         decal->color4ub[1][0] = (unsigned char)(c1[0]*255.0f);
9510         decal->color4ub[1][1] = (unsigned char)(c1[1]*255.0f);
9511         decal->color4ub[1][2] = (unsigned char)(c1[2]*255.0f);
9512         decal->color4ub[1][3] = 255;
9513         decal->color4ub[2][0] = (unsigned char)(c2[0]*255.0f);
9514         decal->color4ub[2][1] = (unsigned char)(c2[1]*255.0f);
9515         decal->color4ub[2][2] = (unsigned char)(c2[2]*255.0f);
9516         decal->color4ub[2][3] = 255;
9517         decal->vertex3f[0][0] = v0[0];
9518         decal->vertex3f[0][1] = v0[1];
9519         decal->vertex3f[0][2] = v0[2];
9520         decal->vertex3f[1][0] = v1[0];
9521         decal->vertex3f[1][1] = v1[1];
9522         decal->vertex3f[1][2] = v1[2];
9523         decal->vertex3f[2][0] = v2[0];
9524         decal->vertex3f[2][1] = v2[1];
9525         decal->vertex3f[2][2] = v2[2];
9526         decal->texcoord2f[0][0] = t0[0];
9527         decal->texcoord2f[0][1] = t0[1];
9528         decal->texcoord2f[1][0] = t1[0];
9529         decal->texcoord2f[1][1] = t1[1];
9530         decal->texcoord2f[2][0] = t2[0];
9531         decal->texcoord2f[2][1] = t2[1];
9532 }
9533
9534 extern cvar_t cl_decals_bias;
9535 extern cvar_t cl_decals_models;
9536 extern cvar_t cl_decals_newsystem_intensitymultiplier;
9537 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)
9538 {
9539         matrix4x4_t projection;
9540         decalsystem_t *decalsystem;
9541         qboolean dynamic;
9542         dp_model_t *model;
9543         const float *vertex3f;
9544         const msurface_t *surface;
9545         const msurface_t *surfaces;
9546         const int *surfacelist;
9547         const texture_t *texture;
9548         int numvertices;
9549         int numtriangles;
9550         int numsurfacelist;
9551         int surfacelistindex;
9552         int surfaceindex;
9553         int triangleindex;
9554         int decalsurfaceindex;
9555         int cornerindex;
9556         int index;
9557         int numpoints;
9558         const int *e;
9559         float localorigin[3];
9560         float localnormal[3];
9561         float localmins[3];
9562         float localmaxs[3];
9563         float localsize;
9564         float ilocalsize;
9565         float v[9][3];
9566         float tc[9][2];
9567         float c[9][4];
9568         //float normal[3];
9569         float planes[6][4];
9570         float f;
9571         float points[2][9][3];
9572         float angles[3];
9573         float temp[3];
9574
9575         decalsystem = &ent->decalsystem;
9576         model = ent->model;
9577         if (!model || !ent->allowdecals || ent->alpha < 1 || (ent->flags & (RENDER_ADDITIVE | RENDER_NODEPTHTEST)))
9578         {
9579                 R_DecalSystem_Reset(&ent->decalsystem);
9580                 return;
9581         }
9582
9583         if (!model->brush.data_nodes && !cl_decals_models.integer)
9584         {
9585                 if (decalsystem->model)
9586                         R_DecalSystem_Reset(decalsystem);
9587                 return;
9588         }
9589
9590         if (decalsystem->model != model)
9591                 R_DecalSystem_Reset(decalsystem);
9592         decalsystem->model = model;
9593
9594         RSurf_ActiveModelEntity(ent, false, false, false);
9595
9596         Matrix4x4_Transform(&rsurface.inversematrix, worldorigin, localorigin);
9597         Matrix4x4_Transform3x3(&rsurface.inversematrix, worldnormal, localnormal);
9598         VectorNormalize(localnormal);
9599         localsize = worldsize*rsurface.inversematrixscale;
9600         ilocalsize = 1.0f / localsize;
9601         localmins[0] = localorigin[0] - localsize;
9602         localmins[1] = localorigin[1] - localsize;
9603         localmins[2] = localorigin[2] - localsize;
9604         localmaxs[0] = localorigin[0] + localsize;
9605         localmaxs[1] = localorigin[1] + localsize;
9606         localmaxs[2] = localorigin[2] + localsize;
9607
9608         //VectorCopy(localnormal, planes[4]);
9609         //VectorVectors(planes[4], planes[2], planes[0]);
9610         AnglesFromVectors(angles, localnormal, NULL, false);
9611         AngleVectors(angles, planes[0], planes[2], planes[4]);
9612         VectorNegate(planes[0], planes[1]);
9613         VectorNegate(planes[2], planes[3]);
9614         VectorNegate(planes[4], planes[5]);
9615         planes[0][3] = DotProduct(planes[0], localorigin) - localsize;
9616         planes[1][3] = DotProduct(planes[1], localorigin) - localsize;
9617         planes[2][3] = DotProduct(planes[2], localorigin) - localsize;
9618         planes[3][3] = DotProduct(planes[3], localorigin) - localsize;
9619         planes[4][3] = DotProduct(planes[4], localorigin) - localsize;
9620         planes[5][3] = DotProduct(planes[5], localorigin) - localsize;
9621
9622 #if 1
9623 // works
9624 {
9625         matrix4x4_t forwardprojection;
9626         Matrix4x4_CreateFromQuakeEntity(&forwardprojection, localorigin[0], localorigin[1], localorigin[2], angles[0], angles[1], angles[2], localsize);
9627         Matrix4x4_Invert_Simple(&projection, &forwardprojection);
9628 }
9629 #else
9630 // broken
9631 {
9632         float projectionvector[4][3];
9633         VectorScale(planes[0], ilocalsize, projectionvector[0]);
9634         VectorScale(planes[2], ilocalsize, projectionvector[1]);
9635         VectorScale(planes[4], ilocalsize, projectionvector[2]);
9636         projectionvector[0][0] = planes[0][0] * ilocalsize;
9637         projectionvector[0][1] = planes[1][0] * ilocalsize;
9638         projectionvector[0][2] = planes[2][0] * ilocalsize;
9639         projectionvector[1][0] = planes[0][1] * ilocalsize;
9640         projectionvector[1][1] = planes[1][1] * ilocalsize;
9641         projectionvector[1][2] = planes[2][1] * ilocalsize;
9642         projectionvector[2][0] = planes[0][2] * ilocalsize;
9643         projectionvector[2][1] = planes[1][2] * ilocalsize;
9644         projectionvector[2][2] = planes[2][2] * ilocalsize;
9645         projectionvector[3][0] = -(localorigin[0]*projectionvector[0][0]+localorigin[1]*projectionvector[1][0]+localorigin[2]*projectionvector[2][0]);
9646         projectionvector[3][1] = -(localorigin[0]*projectionvector[0][1]+localorigin[1]*projectionvector[1][1]+localorigin[2]*projectionvector[2][1]);
9647         projectionvector[3][2] = -(localorigin[0]*projectionvector[0][2]+localorigin[1]*projectionvector[1][2]+localorigin[2]*projectionvector[2][2]);
9648         Matrix4x4_FromVectors(&projection, projectionvector[0], projectionvector[1], projectionvector[2], projectionvector[3]);
9649 }
9650 #endif
9651
9652         dynamic = model->surfmesh.isanimated;
9653         vertex3f = rsurface.modelvertex3f;
9654         numsurfacelist = model->nummodelsurfaces;
9655         surfacelist = model->sortedmodelsurfaces;
9656         surfaces = model->data_surfaces;
9657         for (surfacelistindex = 0;surfacelistindex < numsurfacelist;surfacelistindex++)
9658         {
9659                 surfaceindex = surfacelist[surfacelistindex];
9660                 surface = surfaces + surfaceindex;
9661                 // skip transparent surfaces
9662                 texture = surface->texture;
9663                 if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
9664                         continue;
9665                 if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS)
9666                         continue;
9667                 if (!dynamic && !BoxesOverlap(surface->mins, surface->maxs, localmins, localmaxs))
9668                         continue;
9669                 decalsurfaceindex = ent == r_refdef.scene.worldentity ? surfaceindex : -1;
9670                 numvertices = surface->num_vertices;
9671                 numtriangles = surface->num_triangles;
9672                 for (triangleindex = 0, e = model->surfmesh.data_element3i + 3*surface->num_firsttriangle;triangleindex < numtriangles;triangleindex++, e += 3)
9673                 {
9674                         for (cornerindex = 0;cornerindex < 3;cornerindex++)
9675                         {
9676                                 index = 3*e[cornerindex];
9677                                 VectorCopy(vertex3f + index, v[cornerindex]);
9678                         }
9679                         // cull backfaces
9680                         //TriangleNormal(v[0], v[1], v[2], normal);
9681                         //if (DotProduct(normal, localnormal) < 0.0f)
9682                         //      continue;
9683                         // clip by each of the box planes formed from the projection matrix
9684                         // if anything survives, we emit the decal
9685                         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]);
9686                         if (numpoints < 3)
9687                                 continue;
9688                         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]);
9689                         if (numpoints < 3)
9690                                 continue;
9691                         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]);
9692                         if (numpoints < 3)
9693                                 continue;
9694                         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]);
9695                         if (numpoints < 3)
9696                                 continue;
9697                         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]);
9698                         if (numpoints < 3)
9699                                 continue;
9700                         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]);
9701                         if (numpoints < 3)
9702                                 continue;
9703                         // some part of the triangle survived, so we have to accept it...
9704                         if (dynamic)
9705                         {
9706                                 // dynamic always uses the original triangle
9707                                 numpoints = 3;
9708                                 for (cornerindex = 0;cornerindex < 3;cornerindex++)
9709                                 {
9710                                         index = 3*e[cornerindex];
9711                                         VectorCopy(vertex3f + index, v[cornerindex]);
9712                                 }
9713                         }
9714                         for (cornerindex = 0;cornerindex < numpoints;cornerindex++)
9715                         {
9716                                 // convert vertex positions to texcoords
9717                                 Matrix4x4_Transform(&projection, v[cornerindex], temp);
9718                                 tc[cornerindex][0] = (temp[1]+1.0f)*0.5f * (s2-s1) + s1;
9719                                 tc[cornerindex][1] = (temp[2]+1.0f)*0.5f * (t2-t1) + t1;
9720                                 // calculate distance fade from the projection origin
9721                                 f = a * (1.0f-fabs(temp[0])) * cl_decals_newsystem_intensitymultiplier.value;
9722                                 f = bound(0.0f, f, 1.0f);
9723                                 c[cornerindex][0] = r * f;
9724                                 c[cornerindex][1] = g * f;
9725                                 c[cornerindex][2] = b * f;
9726                                 c[cornerindex][3] = 1.0f;
9727                                 //VectorMA(v[cornerindex], cl_decals_bias.value, localnormal, v[cornerindex]);
9728                         }
9729                         if (dynamic)
9730                                 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);
9731                         else
9732                                 for (cornerindex = 0;cornerindex < numpoints-2;cornerindex++)
9733                                         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);
9734                 }
9735         }
9736 }
9737
9738 // do not call this outside of rendering code - use R_DecalSystem_SplatEntities instead
9739 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)
9740 {
9741         int renderentityindex;
9742         float worldmins[3];
9743         float worldmaxs[3];
9744         entity_render_t *ent;
9745
9746         if (!cl_decals_newsystem.integer)
9747                 return;
9748
9749         worldmins[0] = worldorigin[0] - worldsize;
9750         worldmins[1] = worldorigin[1] - worldsize;
9751         worldmins[2] = worldorigin[2] - worldsize;
9752         worldmaxs[0] = worldorigin[0] + worldsize;
9753         worldmaxs[1] = worldorigin[1] + worldsize;
9754         worldmaxs[2] = worldorigin[2] + worldsize;
9755
9756         R_DecalSystem_SplatEntity(r_refdef.scene.worldentity, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
9757
9758         for (renderentityindex = 0;renderentityindex < r_refdef.scene.numentities;renderentityindex++)
9759         {
9760                 ent = r_refdef.scene.entities[renderentityindex];
9761                 if (!BoxesOverlap(ent->mins, ent->maxs, worldmins, worldmaxs))
9762                         continue;
9763
9764                 R_DecalSystem_SplatEntity(ent, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
9765         }
9766 }
9767
9768 typedef struct r_decalsystem_splatqueue_s
9769 {
9770         vec3_t worldorigin;
9771         vec3_t worldnormal;
9772         float color[4];
9773         float tcrange[4];
9774         float worldsize;
9775         int decalsequence;
9776 }
9777 r_decalsystem_splatqueue_t;
9778
9779 int r_decalsystem_numqueued = 0;
9780 #define MAX_DECALSYSTEM_QUEUE 1024
9781 r_decalsystem_splatqueue_t r_decalsystem_queue[MAX_DECALSYSTEM_QUEUE];
9782
9783 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)
9784 {
9785         r_decalsystem_splatqueue_t *queue;
9786
9787         if (!cl_decals_newsystem.integer || r_decalsystem_numqueued == MAX_DECALSYSTEM_QUEUE)
9788                 return;
9789
9790         queue = &r_decalsystem_queue[r_decalsystem_numqueued++];
9791         VectorCopy(worldorigin, queue->worldorigin);
9792         VectorCopy(worldnormal, queue->worldnormal);
9793         Vector4Set(queue->color, r, g, b, a);
9794         Vector4Set(queue->tcrange, s1, t1, s2, t2);
9795         queue->worldsize = worldsize;
9796         queue->decalsequence = cl.decalsequence++;
9797 }
9798
9799 static void R_DecalSystem_ApplySplatEntitiesQueue(void)
9800 {
9801         int i;
9802         r_decalsystem_splatqueue_t *queue;
9803
9804         for (i = 0, queue = r_decalsystem_queue;i < r_decalsystem_numqueued;i++, queue++)
9805                 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);
9806         r_decalsystem_numqueued = 0;
9807 }
9808
9809 extern cvar_t cl_decals_max;
9810 static void R_DrawModelDecals_FadeEntity(entity_render_t *ent)
9811 {
9812         int i;
9813         decalsystem_t *decalsystem = &ent->decalsystem;
9814         int numdecals;
9815         int killsequence;
9816         tridecal_t *decal;
9817         float frametime;
9818         float lifetime;
9819
9820         if (!decalsystem->numdecals)
9821                 return;
9822
9823         if (r_showsurfaces.integer)
9824                 return;
9825
9826         if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
9827         {
9828                 R_DecalSystem_Reset(decalsystem);
9829                 return;
9830         }
9831
9832         killsequence = cl.decalsequence - max(1, cl_decals_max.integer);
9833         lifetime = cl_decals_time.value + cl_decals_fadetime.value;
9834
9835         if (decalsystem->lastupdatetime)
9836                 frametime = (cl.time - decalsystem->lastupdatetime);
9837         else
9838                 frametime = 0;
9839         decalsystem->lastupdatetime = cl.time;
9840         decal = decalsystem->decals;
9841         numdecals = decalsystem->numdecals;
9842
9843         for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
9844         {
9845                 if (decal->color4ub[0][3])
9846                 {
9847                         decal->lived += frametime;
9848                         if (killsequence - decal->decalsequence > 0 || decal->lived >= lifetime)
9849                         {
9850                                 memset(decal, 0, sizeof(*decal));
9851                                 if (decalsystem->freedecal > i)
9852                                         decalsystem->freedecal = i;
9853                         }
9854                 }
9855         }
9856         decal = decalsystem->decals;
9857         while (numdecals > 0 && !decal[numdecals-1].color4ub[0][3])
9858                 numdecals--;
9859
9860         // collapse the array by shuffling the tail decals into the gaps
9861         for (;;)
9862         {
9863                 while (decalsystem->freedecal < numdecals && decal[decalsystem->freedecal].color4ub[0][3])
9864                         decalsystem->freedecal++;
9865                 if (decalsystem->freedecal == numdecals)
9866                         break;
9867                 decal[decalsystem->freedecal] = decal[--numdecals];
9868         }
9869
9870         decalsystem->numdecals = numdecals;
9871
9872         if (numdecals <= 0)
9873         {
9874                 // if there are no decals left, reset decalsystem
9875                 R_DecalSystem_Reset(decalsystem);
9876         }
9877 }
9878
9879 extern skinframe_t *decalskinframe;
9880 static void R_DrawModelDecals_Entity(entity_render_t *ent)
9881 {
9882         int i;
9883         decalsystem_t *decalsystem = &ent->decalsystem;
9884         int numdecals;
9885         tridecal_t *decal;
9886         float fadedelay;
9887         float faderate;
9888         float alpha;
9889         float *v3f;
9890         float *c4f;
9891         float *t2f;
9892         const int *e;
9893         const unsigned char *surfacevisible = ent == r_refdef.scene.worldentity ? r_refdef.viewcache.world_surfacevisible : NULL;
9894         int numtris = 0;
9895
9896         numdecals = decalsystem->numdecals;
9897         if (!numdecals)
9898                 return;
9899
9900         if (r_showsurfaces.integer)
9901                 return;
9902
9903         if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
9904         {
9905                 R_DecalSystem_Reset(decalsystem);
9906                 return;
9907         }
9908
9909         // if the model is static it doesn't matter what value we give for
9910         // wantnormals and wanttangents, so this logic uses only rules applicable
9911         // to a model, knowing that they are meaningless otherwise
9912         if (ent == r_refdef.scene.worldentity)
9913                 RSurf_ActiveWorldEntity();
9914         else
9915                 RSurf_ActiveModelEntity(ent, false, false, false);
9916
9917         decalsystem->lastupdatetime = cl.time;
9918         decal = decalsystem->decals;
9919
9920         fadedelay = cl_decals_time.value;
9921         faderate = 1.0f / max(0.001f, cl_decals_fadetime.value);
9922
9923         // update vertex positions for animated models
9924         v3f = decalsystem->vertex3f;
9925         c4f = decalsystem->color4f;
9926         t2f = decalsystem->texcoord2f;
9927         for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
9928         {
9929                 if (!decal->color4ub[0][3])
9930                         continue;
9931
9932                 if (surfacevisible && !surfacevisible[decal->surfaceindex])
9933                         continue;
9934
9935                 // update color values for fading decals
9936                 if (decal->lived >= cl_decals_time.value)
9937                 {
9938                         alpha = 1 - faderate * (decal->lived - cl_decals_time.value);
9939                         alpha *= (1.0f/255.0f);
9940                 }
9941                 else
9942                         alpha = 1.0f/255.0f;
9943
9944                 c4f[ 0] = decal->color4ub[0][0] * alpha;
9945                 c4f[ 1] = decal->color4ub[0][1] * alpha;
9946                 c4f[ 2] = decal->color4ub[0][2] * alpha;
9947                 c4f[ 3] = 1;
9948                 c4f[ 4] = decal->color4ub[1][0] * alpha;
9949                 c4f[ 5] = decal->color4ub[1][1] * alpha;
9950                 c4f[ 6] = decal->color4ub[1][2] * alpha;
9951                 c4f[ 7] = 1;
9952                 c4f[ 8] = decal->color4ub[2][0] * alpha;
9953                 c4f[ 9] = decal->color4ub[2][1] * alpha;
9954                 c4f[10] = decal->color4ub[2][2] * alpha;
9955                 c4f[11] = 1;
9956
9957                 t2f[0] = decal->texcoord2f[0][0];
9958                 t2f[1] = decal->texcoord2f[0][1];
9959                 t2f[2] = decal->texcoord2f[1][0];
9960                 t2f[3] = decal->texcoord2f[1][1];
9961                 t2f[4] = decal->texcoord2f[2][0];
9962                 t2f[5] = decal->texcoord2f[2][1];
9963
9964                 // update vertex positions for animated models
9965                 if (decal->triangleindex >= 0 && decal->triangleindex < rsurface.modelnum_triangles)
9966                 {
9967                         e = rsurface.modelelement3i + 3*decal->triangleindex;
9968                         VectorCopy(rsurface.vertex3f + 3*e[0], v3f);
9969                         VectorCopy(rsurface.vertex3f + 3*e[1], v3f + 3);
9970                         VectorCopy(rsurface.vertex3f + 3*e[2], v3f + 6);
9971                 }
9972                 else
9973                 {
9974                         VectorCopy(decal->vertex3f[0], v3f);
9975                         VectorCopy(decal->vertex3f[1], v3f + 3);
9976                         VectorCopy(decal->vertex3f[2], v3f + 6);
9977                 }
9978
9979                 v3f += 9;
9980                 c4f += 12;
9981                 t2f += 6;
9982                 numtris++;
9983         }
9984
9985         if (numtris > 0)
9986         {
9987                 r_refdef.stats.drawndecals += numtris;
9988
9989                 if (r_refdef.fogenabled)
9990                 {
9991                         switch(vid.renderpath)
9992                         {
9993                         case RENDERPATH_GL20:
9994                         case RENDERPATH_CGGL:
9995                         case RENDERPATH_GL13:
9996                         case RENDERPATH_GL11:
9997                                 for (i = 0, v3f = decalsystem->vertex3f, c4f = decalsystem->color4f;i < numtris*3;i++, v3f += 3, c4f += 4)
9998                                 {
9999                                         alpha = RSurf_FogVertex(v3f);
10000                                         c4f[0] *= alpha;
10001                                         c4f[1] *= alpha;
10002                                         c4f[2] *= alpha;
10003                                 }
10004                                 break;
10005                         }
10006                 }
10007
10008                 // now render the decals all at once
10009                 // (this assumes they all use one particle font texture!)
10010                 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);
10011                 R_Mesh_ResetTextureState();
10012                 R_Mesh_VertexPointer(decalsystem->vertex3f, 0, 0);
10013                 R_Mesh_TexCoordPointer(0, 2, decalsystem->texcoord2f, 0, 0);
10014                 R_Mesh_ColorPointer(decalsystem->color4f, 0, 0);
10015                 GL_DepthMask(false);
10016                 GL_DepthRange(0, 1);
10017                 GL_PolygonOffset(rsurface.basepolygonfactor + r_polygonoffset_decals_factor.value, rsurface.basepolygonoffset + r_polygonoffset_decals_offset.value);
10018                 GL_DepthTest(true);
10019                 GL_CullFace(GL_NONE);
10020                 GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
10021                 R_SetupShader_Generic(decalskinframe->base, NULL, GL_MODULATE, 1);
10022                 GL_LockArrays(0, numtris * 3);
10023                 R_Mesh_Draw(0, numtris * 3, 0, numtris, decalsystem->element3i, decalsystem->element3s, 0, 0);
10024                 GL_LockArrays(0, 0);
10025         }
10026 }
10027
10028 static void R_DrawModelDecals(void)
10029 {
10030         int i, numdecals;
10031
10032         // fade faster when there are too many decals
10033         numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
10034         for (i = 0;i < r_refdef.scene.numentities;i++)
10035                 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
10036
10037         R_DrawModelDecals_FadeEntity(r_refdef.scene.worldentity);
10038         for (i = 0;i < r_refdef.scene.numentities;i++)
10039                 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
10040                         R_DrawModelDecals_FadeEntity(r_refdef.scene.entities[i]);
10041
10042         R_DecalSystem_ApplySplatEntitiesQueue();
10043
10044         numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
10045         for (i = 0;i < r_refdef.scene.numentities;i++)
10046                 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
10047
10048         r_refdef.stats.totaldecals += numdecals;
10049
10050         if (r_showsurfaces.integer)
10051                 return;
10052
10053         R_DrawModelDecals_Entity(r_refdef.scene.worldentity);
10054
10055         for (i = 0;i < r_refdef.scene.numentities;i++)
10056         {
10057                 if (!r_refdef.viewcache.entityvisible[i])
10058                         continue;
10059                 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
10060                         R_DrawModelDecals_Entity(r_refdef.scene.entities[i]);
10061         }
10062 }
10063
10064 void R_DrawDebugModel(void)
10065 {
10066         entity_render_t *ent = rsurface.entity;
10067         int i, j, k, l, flagsmask;
10068         const int *elements;
10069         q3mbrush_t *brush;
10070         const msurface_t *surface;
10071         dp_model_t *model = ent->model;
10072         vec3_t v;
10073
10074         flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WALL;
10075
10076         R_Mesh_ColorPointer(NULL, 0, 0);
10077         R_Mesh_ResetTextureState();
10078         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
10079         GL_DepthRange(0, 1);
10080         GL_DepthTest(!r_showdisabledepthtest.integer);
10081         GL_DepthMask(false);
10082         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
10083
10084         if (r_showcollisionbrushes.value > 0 && model->brush.num_brushes)
10085         {
10086                 GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
10087                 for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
10088                 {
10089                         if (brush->colbrushf && brush->colbrushf->numtriangles)
10090                         {
10091                                 R_Mesh_VertexPointer(brush->colbrushf->points->v, 0, 0);
10092                                 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);
10093                                 R_Mesh_Draw(0, brush->colbrushf->numpoints, 0, brush->colbrushf->numtriangles, brush->colbrushf->elements, NULL, 0, 0);
10094                         }
10095                 }
10096                 for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
10097                 {
10098                         if (surface->num_collisiontriangles)
10099                         {
10100                                 R_Mesh_VertexPointer(surface->data_collisionvertex3f, 0, 0);
10101                                 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);
10102                                 R_Mesh_Draw(0, surface->num_collisionvertices, 0, surface->num_collisiontriangles, surface->data_collisionelement3i, NULL, 0, 0);
10103                         }
10104                 }
10105         }
10106
10107         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
10108
10109         if (r_showtris.integer || r_shownormals.integer)
10110         {
10111                 if (r_showdisabledepthtest.integer)
10112                 {
10113                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
10114                         GL_DepthMask(false);
10115                 }
10116                 else
10117                 {
10118                         GL_BlendFunc(GL_ONE, GL_ZERO);
10119                         GL_DepthMask(true);
10120                 }
10121                 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
10122                 {
10123                         if (ent == r_refdef.scene.worldentity && !r_refdef.viewcache.world_surfacevisible[j])
10124                                 continue;
10125                         rsurface.texture = R_GetCurrentTexture(surface->texture);
10126                         if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
10127                         {
10128                                 RSurf_PrepareVerticesForBatch(true, true, 1, &surface);
10129                                 if (r_showtris.value > 0)
10130                                 {
10131                                         if (!rsurface.texture->currentlayers->depthmask)
10132                                                 GL_Color(r_refdef.view.colorscale, 0, 0, r_showtris.value);
10133                                         else if (ent == r_refdef.scene.worldentity)
10134                                                 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, r_showtris.value);
10135                                         else
10136                                                 GL_Color(0, r_refdef.view.colorscale, 0, r_showtris.value);
10137                                         elements = (model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);
10138                                         R_Mesh_VertexPointer(rsurface.vertex3f, 0, 0);
10139                                         R_Mesh_ColorPointer(NULL, 0, 0);
10140                                         R_Mesh_TexCoordPointer(0, 0, NULL, 0, 0);
10141                                         qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
10142                                         //R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, model->surfmesh.data_element3i, NULL, 0, 0);
10143                                         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);
10144                                         qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
10145                                         CHECKGLERROR
10146                                 }
10147                                 if (r_shownormals.value < 0)
10148                                 {
10149                                         qglBegin(GL_LINES);
10150                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
10151                                         {
10152                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
10153                                                 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
10154                                                 qglVertex3f(v[0], v[1], v[2]);
10155                                                 VectorMA(v, -r_shownormals.value, rsurface.svector3f + l * 3, v);
10156                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
10157                                                 qglVertex3f(v[0], v[1], v[2]);
10158                                         }
10159                                         qglEnd();
10160                                         CHECKGLERROR
10161                                 }
10162                                 if (r_shownormals.value > 0)
10163                                 {
10164                                         qglBegin(GL_LINES);
10165                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
10166                                         {
10167                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
10168                                                 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
10169                                                 qglVertex3f(v[0], v[1], v[2]);
10170                                                 VectorMA(v, r_shownormals.value, rsurface.svector3f + l * 3, v);
10171                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
10172                                                 qglVertex3f(v[0], v[1], v[2]);
10173                                         }
10174                                         qglEnd();
10175                                         CHECKGLERROR
10176                                         qglBegin(GL_LINES);
10177                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
10178                                         {
10179                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
10180                                                 GL_Color(0, r_refdef.view.colorscale, 0, 1);
10181                                                 qglVertex3f(v[0], v[1], v[2]);
10182                                                 VectorMA(v, r_shownormals.value, rsurface.tvector3f + l * 3, v);
10183                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
10184                                                 qglVertex3f(v[0], v[1], v[2]);
10185                                         }
10186                                         qglEnd();
10187                                         CHECKGLERROR
10188                                         qglBegin(GL_LINES);
10189                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
10190                                         {
10191                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
10192                                                 GL_Color(0, 0, r_refdef.view.colorscale, 1);
10193                                                 qglVertex3f(v[0], v[1], v[2]);
10194                                                 VectorMA(v, r_shownormals.value, rsurface.normal3f + l * 3, v);
10195                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
10196                                                 qglVertex3f(v[0], v[1], v[2]);
10197                                         }
10198                                         qglEnd();
10199                                         CHECKGLERROR
10200                                 }
10201                         }
10202                 }
10203                 rsurface.texture = NULL;
10204         }
10205 }
10206
10207 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
10208 int r_maxsurfacelist = 0;
10209 const msurface_t **r_surfacelist = NULL;
10210 void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
10211 {
10212         int i, j, endj, f, flagsmask;
10213         texture_t *t;
10214         dp_model_t *model = r_refdef.scene.worldmodel;
10215         msurface_t *surfaces;
10216         unsigned char *update;
10217         int numsurfacelist = 0;
10218         if (model == NULL)
10219                 return;
10220
10221         if (r_maxsurfacelist < model->num_surfaces)
10222         {
10223                 r_maxsurfacelist = model->num_surfaces;
10224                 if (r_surfacelist)
10225                         Mem_Free((msurface_t**)r_surfacelist);
10226                 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
10227         }
10228
10229         RSurf_ActiveWorldEntity();
10230
10231         surfaces = model->data_surfaces;
10232         update = model->brushq1.lightmapupdateflags;
10233
10234         // update light styles on this submodel
10235         if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
10236         {
10237                 model_brush_lightstyleinfo_t *style;
10238                 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
10239                 {
10240                         if (style->value != r_refdef.scene.lightstylevalue[style->style])
10241                         {
10242                                 int *list = style->surfacelist;
10243                                 style->value = r_refdef.scene.lightstylevalue[style->style];
10244                                 for (j = 0;j < style->numsurfaces;j++)
10245                                         update[list[j]] = true;
10246                         }
10247                 }
10248         }
10249
10250         flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
10251
10252         if (debug)
10253         {
10254                 R_DrawDebugModel();
10255                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10256                 return;
10257         }
10258
10259         f = 0;
10260         t = NULL;
10261         rsurface.uselightmaptexture = false;
10262         rsurface.texture = NULL;
10263         rsurface.rtlight = NULL;
10264         numsurfacelist = 0;
10265         // add visible surfaces to draw list
10266         for (i = 0;i < model->nummodelsurfaces;i++)
10267         {
10268                 j = model->sortedmodelsurfaces[i];
10269                 if (r_refdef.viewcache.world_surfacevisible[j])
10270                         r_surfacelist[numsurfacelist++] = surfaces + j;
10271         }
10272         // update lightmaps if needed
10273         if (update)
10274         {
10275                 int updated = 0;
10276                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
10277                 {
10278                         if (r_refdef.viewcache.world_surfacevisible[j])
10279                         {
10280                                 if (update[j])
10281                                 {
10282                                         updated++;
10283                                         R_BuildLightMap(r_refdef.scene.worldentity, surfaces + j);
10284                                 }
10285                         }
10286                 }
10287                 if (updated)
10288                 {
10289                         int count = model->brushq3.num_mergedlightmaps;
10290                         for (i = 0;i < count;i++)
10291                         {
10292                                 if (model->brushq3.data_deluxemaps[i])
10293                                         R_FlushTexture(model->brushq3.data_deluxemaps[i]);
10294                                 if (model->brushq3.data_lightmaps[i])
10295                                         R_FlushTexture(model->brushq3.data_lightmaps[i]);
10296                         }
10297                 }
10298         }
10299         // don't do anything if there were no surfaces
10300         if (!numsurfacelist)
10301         {
10302                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10303                 return;
10304         }
10305         R_QueueWorldSurfaceList(numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
10306         GL_AlphaTest(false);
10307
10308         // add to stats if desired
10309         if (r_speeds.integer && !skysurfaces && !depthonly)
10310         {
10311                 r_refdef.stats.world_surfaces += numsurfacelist;
10312                 for (j = 0;j < numsurfacelist;j++)
10313                         r_refdef.stats.world_triangles += r_surfacelist[j]->num_triangles;
10314         }
10315
10316         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10317 }
10318
10319 void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
10320 {
10321         int i, j, endj, f, flagsmask;
10322         texture_t *t;
10323         dp_model_t *model = ent->model;
10324         msurface_t *surfaces;
10325         unsigned char *update;
10326         int numsurfacelist = 0;
10327         if (model == NULL)
10328                 return;
10329
10330         if (r_maxsurfacelist < model->num_surfaces)
10331         {
10332                 r_maxsurfacelist = model->num_surfaces;
10333                 if (r_surfacelist)
10334                         Mem_Free((msurface_t **)r_surfacelist);
10335                 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
10336         }
10337
10338         // if the model is static it doesn't matter what value we give for
10339         // wantnormals and wanttangents, so this logic uses only rules applicable
10340         // to a model, knowing that they are meaningless otherwise
10341         if (ent == r_refdef.scene.worldentity)
10342                 RSurf_ActiveWorldEntity();
10343         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
10344                 RSurf_ActiveModelEntity(ent, false, false, false);
10345         else if (prepass)
10346                 RSurf_ActiveModelEntity(ent, true, true, true);
10347         else if (depthonly)
10348                 RSurf_ActiveModelEntity(ent, false, false, false);
10349         else
10350         {
10351                 switch (vid.renderpath)
10352                 {
10353                 case RENDERPATH_GL20:
10354                 case RENDERPATH_CGGL:
10355                         RSurf_ActiveModelEntity(ent, true, true, false);
10356                         break;
10357                 case RENDERPATH_GL13:
10358                 case RENDERPATH_GL11:
10359                         RSurf_ActiveModelEntity(ent, true, false, false);
10360                         break;
10361                 }
10362         }
10363
10364         surfaces = model->data_surfaces;
10365         update = model->brushq1.lightmapupdateflags;
10366
10367         // update light styles
10368         if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
10369         {
10370                 model_brush_lightstyleinfo_t *style;
10371                 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
10372                 {
10373                         if (style->value != r_refdef.scene.lightstylevalue[style->style])
10374                         {
10375                                 int *list = style->surfacelist;
10376                                 style->value = r_refdef.scene.lightstylevalue[style->style];
10377                                 for (j = 0;j < style->numsurfaces;j++)
10378                                         update[list[j]] = true;
10379                         }
10380                 }
10381         }
10382
10383         flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
10384
10385         if (debug)
10386         {
10387                 R_DrawDebugModel();
10388                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10389                 return;
10390         }
10391
10392         f = 0;
10393         t = NULL;
10394         rsurface.uselightmaptexture = false;
10395         rsurface.texture = NULL;
10396         rsurface.rtlight = NULL;
10397         numsurfacelist = 0;
10398         // add visible surfaces to draw list
10399         for (i = 0;i < model->nummodelsurfaces;i++)
10400                 r_surfacelist[numsurfacelist++] = surfaces + model->sortedmodelsurfaces[i];
10401         // don't do anything if there were no surfaces
10402         if (!numsurfacelist)
10403         {
10404                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10405                 return;
10406         }
10407         // update lightmaps if needed
10408         if (update)
10409         {
10410                 int updated = 0;
10411                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
10412                 {
10413                         if (update[j])
10414                         {
10415                                 updated++;
10416                                 R_BuildLightMap(ent, surfaces + j);
10417                         }
10418                 }
10419                 if (updated)
10420                 {
10421                         int count = model->brushq3.num_mergedlightmaps;
10422                         for (i = 0;i < count;i++)
10423                         {
10424                                 if (model->brushq3.data_deluxemaps[i])
10425                                         R_FlushTexture(model->brushq3.data_deluxemaps[i]);
10426                                 if (model->brushq3.data_lightmaps[i])
10427                                         R_FlushTexture(model->brushq3.data_lightmaps[i]);
10428                         }
10429                 }
10430         }
10431         if (update)
10432                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
10433                         if (update[j])
10434                                 R_BuildLightMap(ent, surfaces + j);
10435         R_QueueModelSurfaceList(ent, numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
10436         GL_AlphaTest(false);
10437
10438         // add to stats if desired
10439         if (r_speeds.integer && !skysurfaces && !depthonly)
10440         {
10441                 r_refdef.stats.entities_surfaces += numsurfacelist;
10442                 for (j = 0;j < numsurfacelist;j++)
10443                         r_refdef.stats.entities_triangles += r_surfacelist[j]->num_triangles;
10444         }
10445
10446         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10447 }
10448
10449 void R_DrawCustomSurface(skinframe_t *skinframe, const matrix4x4_t *texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qboolean writedepth, qboolean prepass)
10450 {
10451         static texture_t texture;
10452         static msurface_t surface;
10453         const msurface_t *surfacelist = &surface;
10454
10455         // fake enough texture and surface state to render this geometry
10456
10457         texture.update_lastrenderframe = -1; // regenerate this texture
10458         texture.basematerialflags = materialflags | MATERIALFLAG_CUSTOMSURFACE | MATERIALFLAG_WALL;
10459         texture.currentskinframe = skinframe;
10460         texture.currenttexmatrix = *texmatrix; // requires MATERIALFLAG_CUSTOMSURFACE
10461         texture.specularscalemod = 1;
10462         texture.specularpowermod = 1;
10463
10464         surface.texture = &texture;
10465         surface.num_triangles = numtriangles;
10466         surface.num_firsttriangle = firsttriangle;
10467         surface.num_vertices = numvertices;
10468         surface.num_firstvertex = firstvertex;
10469
10470         // now render it
10471         rsurface.texture = R_GetCurrentTexture(surface.texture);
10472         rsurface.uselightmaptexture = false;
10473         R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
10474 }
10475
10476 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)
10477 {
10478         static msurface_t surface;
10479         const msurface_t *surfacelist = &surface;
10480
10481         // fake enough texture and surface state to render this geometry
10482
10483         surface.texture = texture;
10484         surface.num_triangles = numtriangles;
10485         surface.num_firsttriangle = firsttriangle;
10486         surface.num_vertices = numvertices;
10487         surface.num_firstvertex = firstvertex;
10488
10489         // now render it
10490         rsurface.texture = R_GetCurrentTexture(surface.texture);
10491         rsurface.uselightmaptexture = false;
10492         R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
10493 }