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 #include "csprogs.h"
  29 #include "cl_video.h"
  30
  31 mempool_t *r_main_mempool;
  32 rtexturepool_t *r_main_texturepool;
  33
  34 static int r_textureframe = 0; ///< used only by R_GetCurrentTexture
  35
  36 static qboolean r_loadnormalmap;
  37 static qboolean r_loadgloss;
  38 qboolean r_loadfog;
  39 static qboolean r_loaddds;
  40 static qboolean r_savedds;
  41
  42 //
  43 // screen size info
  44 //
  45 r_refdef_t r_refdef;
  46
  47 cvar_t r_motionblur = {CVAR_SAVE, "r_motionblur", "0", "motionblur value scale - 0.5 recommended"};
  48 cvar_t r_damageblur = {CVAR_SAVE, "r_damageblur", "0", "motionblur based on damage"};
  49 cvar_t r_motionblur_vmin = {CVAR_SAVE, "r_motionblur_vmin", "300", "minimum influence from velocity"};
  50 cvar_t r_motionblur_vmax = {CVAR_SAVE, "r_motionblur_vmax", "600", "maximum influence from velocity"};
  51 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)"};
  52 cvar_t r_motionblur_vcoeff = {CVAR_SAVE, "r_motionblur_vcoeff", "0.05", "sliding average reaction time for velocity"};
  53 cvar_t r_motionblur_maxblur = {CVAR_SAVE, "r_motionblur_maxblur", "0.88", "cap for motionblur alpha value"};
  54 cvar_t r_motionblur_randomize = {CVAR_SAVE, "r_motionblur_randomize", "0.1", "randomizing coefficient to workaround ghosting"};
  55
  56 // TODO do we want a r_equalize_entities cvar that works on all ents, or would that be a cheat?
  57 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"};
  58 cvar_t r_equalize_entities_minambient = {CVAR_SAVE, "r_equalize_entities_minambient", "0.5", "light equalizing: ensure at least this ambient/diffuse ratio"};
  59 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)"};
  60 cvar_t r_equalize_entities_to = {CVAR_SAVE, "r_equalize_entities_to", "0.8", "light equalizing: target light level"};
  61
  62 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"};
  63 cvar_t r_useinfinitefarclip = {CVAR_SAVE, "r_useinfinitefarclip", "1", "enables use of a special kind of projection matrix that has an extremely large farclip"};
  64 cvar_t r_farclip_base = {0, "r_farclip_base", "65536", "farclip (furthest visible distance) for rendering when r_useinfinitefarclip is 0"};
  65 cvar_t r_farclip_world = {0, "r_farclip_world", "2", "adds map size to farclip multiplied by this value"};
  66 cvar_t r_nearclip = {0, "r_nearclip", "1", "distance from camera of nearclip plane" };
  67 cvar_t r_showbboxes = {0, "r_showbboxes", "0", "shows bounding boxes of server entities, value controls opacity scaling (1 = 10%,  10 = 100%)"};
  68 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)"};
  69 cvar_t r_showtris = {0, "r_showtris", "0", "shows triangle outlines, value controls brightness (can be above 1)"};
  70 cvar_t r_shownormals = {0, "r_shownormals", "0", "shows per-vertex surface normals and tangent vectors for bumpmapped lighting"};
  71 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"};
  72 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"};
  73 cvar_t r_showcollisionbrushes = {0, "r_showcollisionbrushes", "0", "draws collision brushes in quake3 maps (mode 1), mode 2 disables rendering of world (trippy!)"};
  74 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"};
  75 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"};
  76 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"};
  77 cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating polygons) in world interior in quake1 maps"};
  78 cvar_t r_drawentities = {0, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"};
  79 cvar_t r_draw2d = {0, "r_draw2d","1", "draw 2D stuff (dangerous to turn off)"};
  80 cvar_t r_drawworld = {0, "r_drawworld","1", "draw world (most static stuff)"};
  81 cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1", "draw your weapon model"};
  82 cvar_t r_drawexteriormodel = {0, "r_drawexteriormodel","1", "draw your player model (e.g. in chase cam, reflections)"};
  83 cvar_t r_cullentities_trace = {0, "r_cullentities_trace", "1", "probabistically cull invisible entities"};
  84 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)"};
  85 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)"};
  86 cvar_t r_cullentities_trace_enlarge = {0, "r_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
  87 cvar_t r_cullentities_trace_delay = {0, "r_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
  88 cvar_t r_speeds = {0, "r_speeds","0", "displays rendering statistics and per-subsystem timings"};
  89 cvar_t r_fullbright = {0, "r_fullbright","0", "makes map very bright and renders faster"};
  90 cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1", "opacity of water polygons"};
  91 cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1", "enables dynamic lights (rocket glow and such)"};
  92 cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1", "enables glowing pixels in quake textures (changes need r_restart to take effect)"};
  93 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."};
  94 cvar_t r_shadows_darken = {CVAR_SAVE, "r_shadows_darken", "0.5", "how much shadowed areas will be darkened"};
  95 cvar_t r_shadows_throwdistance = {CVAR_SAVE, "r_shadows_throwdistance", "500", "how far to cast shadows from models"};
  96 cvar_t r_shadows_throwdirection = {CVAR_SAVE, "r_shadows_throwdirection", "0 0 -1", "override throwing direction for r_shadows 2"};
  97 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."};
  98 cvar_t r_shadows_castfrombmodels = {CVAR_SAVE, "r_shadows_castfrombmodels", "0", "do cast shadows from bmodels"};
  99 cvar_t r_shadows_focus = {CVAR_SAVE, "r_shadows_focus", "0 0 0", "offset the shadowed area focus"};
 100 cvar_t r_shadows_shadowmapscale = {CVAR_SAVE, "r_shadows_shadowmapscale", "1", "increases shadowmap quality (multiply global shadowmap precision) for fake shadows. Needs shadowmapping ON."};
 101 cvar_t r_q1bsp_skymasking = {0, "r_q1bsp_skymasking", "1", "allows sky polygons in quake1 maps to obscure other geometry"};
 102 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"};
 103 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"};
 104 cvar_t r_polygonoffset_decals_factor = {0, "r_polygonoffset_decals_factor", "0", "biases depth values of decals to prevent z-fighting artifacts"};
 105 cvar_t r_polygonoffset_decals_offset = {0, "r_polygonoffset_decals_offset", "-14", "biases depth values of decals to prevent z-fighting artifacts"};
 106 cvar_t r_fog_exp2 = {0, "r_fog_exp2", "0", "uses GL_EXP2 fog (as in Nehahra) rather than realistic GL_EXP fog"};
 107 cvar_t r_drawfog = {CVAR_SAVE, "r_drawfog", "1", "allows one to disable fog rendering"};
 108 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"};
 109
 110 cvar_t gl_fogenable = {0, "gl_fogenable", "0", "nehahra fog enable (for Nehahra compatibility only)"};
 111 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25", "nehahra fog density (recommend values below 0.1) (for Nehahra compatibility only)"};
 112 cvar_t gl_fogred = {0, "gl_fogred","0.3", "nehahra fog color red value (for Nehahra compatibility only)"};
 113 cvar_t gl_foggreen = {0, "gl_foggreen","0.3", "nehahra fog color green value (for Nehahra compatibility only)"};
 114 cvar_t gl_fogblue = {0, "gl_fogblue","0.3", "nehahra fog color blue value (for Nehahra compatibility only)"};
 115 cvar_t gl_fogstart = {0, "gl_fogstart", "0", "nehahra fog start distance (for Nehahra compatibility only)"};
 116 cvar_t gl_fogend = {0, "gl_fogend","0", "nehahra fog end distance (for Nehahra compatibility only)"};
 117 cvar_t gl_skyclip = {0, "gl_skyclip", "4608", "nehahra farclip distance - the real fog end (for Nehahra compatibility only)"};
 118
 119 cvar_t r_texture_dds_load = {CVAR_SAVE, "r_texture_dds_load", "0", "load compressed dds/filename.dds texture instead of filename.tga, if the file exists (requires driver support)"};
 120 cvar_t r_texture_dds_save = {CVAR_SAVE, "r_texture_dds_save", "0", "save compressed dds/filename.dds texture when filename.tga is loaded, so that it can be loaded instead next time"};
 121
 122 cvar_t r_texture_convertsRGB_2d = {0, "r_texture_convertsRGB_2d", "0", "load textures as sRGB and convert to linear for proper shading"};
 123 cvar_t r_texture_convertsRGB_skin = {0, "r_texture_convertsRGB_skin", "0", "load textures as sRGB and convert to linear for proper shading"};
 124 cvar_t r_texture_convertsRGB_cubemap = {0, "r_texture_convertsRGB_cubemap", "0", "load textures as sRGB and convert to linear for proper shading"};
 125 cvar_t r_texture_convertsRGB_skybox = {0, "r_texture_convertsRGB_skybox", "0", "load textures as sRGB and convert to linear for proper shading"};
 126 cvar_t r_texture_convertsRGB_particles = {0, "r_texture_convertsRGB_particles", "0", "load textures as sRGB and convert to linear for proper shading"};
 127
 128 cvar_t r_textureunits = {0, "r_textureunits", "32", "number of texture units to use in GL 1.1 and GL 1.3 rendering paths"};
 129 static cvar_t gl_combine = {CVAR_READONLY, "gl_combine", "1", "indicates whether the OpenGL 1.3 rendering path is active"};
 130 static cvar_t r_glsl = {CVAR_READONLY, "r_glsl", "1", "indicates whether the OpenGL 2.0 rendering path is active"};
 131
 132 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)"};
 133 cvar_t r_glsl_offsetmapping = {CVAR_SAVE, "r_glsl_offsetmapping", "0", "offset mapping effect (also known as parallax mapping or virtual displacement mapping)"};
 134 cvar_t r_glsl_offsetmapping_reliefmapping = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"};
 135 cvar_t r_glsl_offsetmapping_scale = {CVAR_SAVE, "r_glsl_offsetmapping_scale", "0.04", "how deep the offset mapping effect is"};
 136 cvar_t r_glsl_postprocess = {CVAR_SAVE, "r_glsl_postprocess", "0", "use a GLSL postprocessing shader"};
 137 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)"};
 138 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)"};
 139 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)"};
 140 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)"};
 141
 142 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)"};
 143 cvar_t r_water_clippingplanebias = {CVAR_SAVE, "r_water_clippingplanebias", "1", "a rather technical setting which avoids black pixels around water edges"};
 144 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"};
 145 cvar_t r_water_refractdistort = {CVAR_SAVE, "r_water_refractdistort", "0.01", "how much water refractions shimmer"};
 146 cvar_t r_water_reflectdistort = {CVAR_SAVE, "r_water_reflectdistort", "0.01", "how much water reflections shimmer"};
 147
 148 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "0", "enables animation smoothing on sprites"};
 149 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"};
 150 cvar_t r_lerplightstyles = {CVAR_SAVE, "r_lerplightstyles", "0", "enable animation smoothing on flickering lights"};
 151 cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1", "makes water scroll around, value controls how much"};
 152
 153 cvar_t r_bloom = {CVAR_SAVE, "r_bloom", "0", "enables bloom effect (makes bright pixels affect neighboring pixels)"};
 154 cvar_t r_bloom_colorscale = {CVAR_SAVE, "r_bloom_colorscale", "1", "how bright the glow is"};
 155 cvar_t r_bloom_brighten = {CVAR_SAVE, "r_bloom_brighten", "2", "how bright the glow is, after subtract/power"};
 156 cvar_t r_bloom_blur = {CVAR_SAVE, "r_bloom_blur", "4", "how large the glow is"};
 157 cvar_t r_bloom_resolution = {CVAR_SAVE, "r_bloom_resolution", "320", "what resolution to perform the bloom effect at (independent of screen resolution)"};
 158 cvar_t r_bloom_colorexponent = {CVAR_SAVE, "r_bloom_colorexponent", "1", "how exagerated the glow is"};
 159 cvar_t r_bloom_colorsubtract = {CVAR_SAVE, "r_bloom_colorsubtract", "0.125", "reduces bloom colors by a certain amount"};
 160
 161 cvar_t r_hdr = {CVAR_SAVE, "r_hdr", "0", "enables High Dynamic Range bloom effect (higher quality version of r_bloom)"};
 162 cvar_t r_hdr_scenebrightness = {CVAR_SAVE, "r_hdr_scenebrightness", "1", "global rendering brightness"};
 163 cvar_t r_hdr_glowintensity = {CVAR_SAVE, "r_hdr_glowintensity", "1", "how bright light emitting textures should appear"};
 164 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)"};
 165
 166 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"};
 167
 168 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"};
 169
 170 cvar_t gl_lightmaps = {0, "gl_lightmaps", "0", "draws only lightmaps, no texture (for level designers)"};
 171
 172 cvar_t r_test = {0, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"};
 173 cvar_t r_batchmode = {0, "r_batchmode", "1", "selects method of rendering multiple surfaces with one driver call (values are 0, 1, 2, etc...)"};
 174 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"};
 175 cvar_t r_track_sprites_flags = {CVAR_SAVE, "r_track_sprites_flags", "1", "1: Rotate sprites accodringly, 2: Make it a continuous rotation"};
 176 cvar_t r_track_sprites_scalew = {CVAR_SAVE, "r_track_sprites_scalew", "1", "width scaling of tracked sprites"};
 177 cvar_t r_track_sprites_scaleh = {CVAR_SAVE, "r_track_sprites_scaleh", "1", "height scaling of tracked sprites"};
 178 cvar_t r_overheadsprites_perspective = {CVAR_SAVE, "r_overheadsprites_perspective", "0.15", "fake perspective effect for SPR_OVERHEAD sprites"};
 179 cvar_t r_overheadsprites_pushback = {CVAR_SAVE, "r_overheadsprites_pushback", "16", "how far to pull the SPR_OVERHEAD sprites toward the eye (used to avoid intersections with 3D models)"};
 180
 181 cvar_t r_glsl_saturation = {CVAR_SAVE, "r_glsl_saturation", "1", "saturation multiplier (only working in glsl!)"};
 182
 183 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)"};
 184
 185 extern cvar_t v_glslgamma;
 186
 187 extern qboolean v_flipped_state;
 188
 189 static struct r_bloomstate_s
 190 {
 191         qboolean enabled;
 192         qboolean hdr;
 193
 194         int bloomwidth, bloomheight;
 195
 196         int screentexturewidth, screentextureheight;
 197         rtexture_t *texture_screen; /// \note also used for motion blur if enabled!
 198
 199         int bloomtexturewidth, bloomtextureheight;
 200         rtexture_t *texture_bloom;
 201
 202         // arrays for rendering the screen passes
 203         float screentexcoord2f[8];
 204         float bloomtexcoord2f[8];
 205         float offsettexcoord2f[8];
 206
 207         r_viewport_t viewport;
 208 }
 209 r_bloomstate;
 210
 211 r_waterstate_t r_waterstate;
 212
 213 /// shadow volume bsp struct with automatically growing nodes buffer
 214 svbsp_t r_svbsp;
 215
 216 rtexture_t *r_texture_blanknormalmap;
 217 rtexture_t *r_texture_white;
 218 rtexture_t *r_texture_grey128;
 219 rtexture_t *r_texture_black;
 220 rtexture_t *r_texture_notexture;
 221 rtexture_t *r_texture_whitecube;
 222 rtexture_t *r_texture_normalizationcube;
 223 rtexture_t *r_texture_fogattenuation;
 224 rtexture_t *r_texture_fogheighttexture;
 225 rtexture_t *r_texture_gammaramps;
 226 unsigned int r_texture_gammaramps_serial;
 227 //rtexture_t *r_texture_fogintensity;
 228 rtexture_t *r_texture_reflectcube;
 229
 230 // TODO: hash lookups?
 231 typedef struct cubemapinfo_s
 232 {
 233         char basename[64];
 234         rtexture_t *texture;
 235 }
 236 cubemapinfo_t;
 237
 238 int r_texture_numcubemaps;
 239 cubemapinfo_t r_texture_cubemaps[MAX_CUBEMAPS];
 240
 241 unsigned int r_queries[MAX_OCCLUSION_QUERIES];
 242 unsigned int r_numqueries;
 243 unsigned int r_maxqueries;
 244
 245 typedef struct r_qwskincache_s
 246 {
 247         char name[MAX_QPATH];
 248         skinframe_t *skinframe;
 249 }
 250 r_qwskincache_t;
 251
 252 static r_qwskincache_t *r_qwskincache;
 253 static int r_qwskincache_size;
 254
 255 /// vertex coordinates for a quad that covers the screen exactly
 256 const float r_screenvertex3f[12] =
 257 {
 258         0, 0, 0,
 259         1, 0, 0,
 260         1, 1, 0,
 261         0, 1, 0
 262 };
 263
 264 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
 265 {
 266         int i;
 267         for (i = 0;i < verts;i++)
 268         {
 269                 out[0] = in[0] * r;
 270                 out[1] = in[1] * g;
 271                 out[2] = in[2] * b;
 272                 out[3] = in[3];
 273                 in += 4;
 274                 out += 4;
 275         }
 276 }
 277
 278 void R_FillColors(float *out, int verts, float r, float g, float b, float a)
 279 {
 280         int i;
 281         for (i = 0;i < verts;i++)
 282         {
 283                 out[0] = r;
 284                 out[1] = g;
 285                 out[2] = b;
 286                 out[3] = a;
 287                 out += 4;
 288         }
 289 }
 290
 291 // FIXME: move this to client?
 292 void FOG_clear(void)
 293 {
 294         if (gamemode == GAME_NEHAHRA)
 295         {
 296                 Cvar_Set("gl_fogenable", "0");
 297                 Cvar_Set("gl_fogdensity", "0.2");
 298                 Cvar_Set("gl_fogred", "0.3");
 299                 Cvar_Set("gl_foggreen", "0.3");
 300                 Cvar_Set("gl_fogblue", "0.3");
 301         }
 302         r_refdef.fog_density = 0;
 303         r_refdef.fog_red = 0;
 304         r_refdef.fog_green = 0;
 305         r_refdef.fog_blue = 0;
 306         r_refdef.fog_alpha = 1;
 307         r_refdef.fog_start = 0;
 308         r_refdef.fog_end = 16384;
 309         r_refdef.fog_height = 1<<30;
 310         r_refdef.fog_fadedepth = 128;
 311         memset(r_refdef.fog_height_texturename, 0, sizeof(r_refdef.fog_height_texturename));
 312 }
 313
 314 static void R_BuildBlankTextures(void)
 315 {
 316         unsigned char data[4];
 317         data[2] = 128; // normal X
 318         data[1] = 128; // normal Y
 319         data[0] = 255; // normal Z
 320         data[3] = 128; // height
 321         r_texture_blanknormalmap = R_LoadTexture2D(r_main_texturepool, "blankbump", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
 322         data[0] = 255;
 323         data[1] = 255;
 324         data[2] = 255;
 325         data[3] = 255;
 326         r_texture_white = R_LoadTexture2D(r_main_texturepool, "blankwhite", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
 327         data[0] = 128;
 328         data[1] = 128;
 329         data[2] = 128;
 330         data[3] = 255;
 331         r_texture_grey128 = R_LoadTexture2D(r_main_texturepool, "blankgrey128", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
 332         data[0] = 0;
 333         data[1] = 0;
 334         data[2] = 0;
 335         data[3] = 255;
 336         r_texture_black = R_LoadTexture2D(r_main_texturepool, "blankblack", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
 337 }
 338
 339 static void R_BuildNoTexture(void)
 340 {
 341         int x, y;
 342         unsigned char pix[16][16][4];
 343         // this makes a light grey/dark grey checkerboard texture
 344         for (y = 0;y < 16;y++)
 345         {
 346                 for (x = 0;x < 16;x++)
 347                 {
 348                         if ((y < 8) ^ (x < 8))
 349                         {
 350                                 pix[y][x][0] = 128;
 351                                 pix[y][x][1] = 128;
 352                                 pix[y][x][2] = 128;
 353                                 pix[y][x][3] = 255;
 354                         }
 355                         else
 356                         {
 357                                 pix[y][x][0] = 64;
 358                                 pix[y][x][1] = 64;
 359                                 pix[y][x][2] = 64;
 360                                 pix[y][x][3] = 255;
 361                         }
 362                 }
 363         }
 364         r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_BGRA, TEXF_MIPMAP | TEXF_PERSISTENT, -1, NULL);
 365 }
 366
 367 static void R_BuildWhiteCube(void)
 368 {
 369         unsigned char data[6*1*1*4];
 370         memset(data, 255, sizeof(data));
 371         r_texture_whitecube = R_LoadTextureCubeMap(r_main_texturepool, "whitecube", 1, data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
 372 }
 373
 374 static void R_BuildNormalizationCube(void)
 375 {
 376         int x, y, side;
 377         vec3_t v;
 378         vec_t s, t, intensity;
 379 #define NORMSIZE 64
 380         unsigned char *data;
 381         data = Mem_Alloc(tempmempool, 6*NORMSIZE*NORMSIZE*4);
 382         for (side = 0;side < 6;side++)
 383         {
 384                 for (y = 0;y < NORMSIZE;y++)
 385                 {
 386                         for (x = 0;x < NORMSIZE;x++)
 387                         {
 388                                 s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
 389                                 t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
 390                                 switch(side)
 391                                 {
 392                                 default:
 393                                 case 0:
 394                                         v[0] = 1;
 395                                         v[1] = -t;
 396                                         v[2] = -s;
 397                                         break;
 398                                 case 1:
 399                                         v[0] = -1;
 400                                         v[1] = -t;
 401                                         v[2] = s;
 402                                         break;
 403                                 case 2:
 404                                         v[0] = s;
 405                                         v[1] = 1;
 406                                         v[2] = t;
 407                                         break;
 408                                 case 3:
 409                                         v[0] = s;
 410                                         v[1] = -1;
 411                                         v[2] = -t;
 412                                         break;
 413                                 case 4:
 414                                         v[0] = s;
 415                                         v[1] = -t;
 416                                         v[2] = 1;
 417                                         break;
 418                                 case 5:
 419                                         v[0] = -s;
 420                                         v[1] = -t;
 421                                         v[2] = -1;
 422                                         break;
 423                                 }
 424                                 intensity = 127.0f / sqrt(DotProduct(v, v));
 425                                 data[((side*64+y)*64+x)*4+2] = (unsigned char)(128.0f + intensity * v[0]);
 426                                 data[((side*64+y)*64+x)*4+1] = (unsigned char)(128.0f + intensity * v[1]);
 427                                 data[((side*64+y)*64+x)*4+0] = (unsigned char)(128.0f + intensity * v[2]);
 428                                 data[((side*64+y)*64+x)*4+3] = 255;
 429                         }
 430                 }
 431         }
 432         r_texture_normalizationcube = R_LoadTextureCubeMap(r_main_texturepool, "normalcube", NORMSIZE, data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
 433         Mem_Free(data);
 434 }
 435
 436 static void R_BuildFogTexture(void)
 437 {
 438         int x, b;
 439 #define FOGWIDTH 256
 440         unsigned char data1[FOGWIDTH][4];
 441         //unsigned char data2[FOGWIDTH][4];
 442         double d, r, alpha;
 443
 444         r_refdef.fogmasktable_start = r_refdef.fog_start;
 445         r_refdef.fogmasktable_alpha = r_refdef.fog_alpha;
 446         r_refdef.fogmasktable_range = r_refdef.fogrange;
 447         r_refdef.fogmasktable_density = r_refdef.fog_density;
 448
 449         r = r_refdef.fogmasktable_range / FOGMASKTABLEWIDTH;
 450         for (x = 0;x < FOGMASKTABLEWIDTH;x++)
 451         {
 452                 d = (x * r - r_refdef.fogmasktable_start);
 453                 if(developer_extra.integer)
 454                         Con_DPrintf("%f ", d);
 455                 d = max(0, d);
 456                 if (r_fog_exp2.integer)
 457                         alpha = exp(-r_refdef.fogmasktable_density * r_refdef.fogmasktable_density * 0.0001 * d * d);
 458                 else
 459                         alpha = exp(-r_refdef.fogmasktable_density * 0.004 * d);
 460                 if(developer_extra.integer)
 461                         Con_DPrintf(" : %f ", alpha);
 462                 alpha = 1 - (1 - alpha) * r_refdef.fogmasktable_alpha;
 463                 if(developer_extra.integer)
 464                         Con_DPrintf(" = %f\n", alpha);
 465                 r_refdef.fogmasktable[x] = bound(0, alpha, 1);
 466         }
 467
 468         for (x = 0;x < FOGWIDTH;x++)
 469         {
 470                 b = (int)(r_refdef.fogmasktable[x * (FOGMASKTABLEWIDTH - 1) / (FOGWIDTH - 1)] * 255);
 471                 data1[x][0] = b;
 472                 data1[x][1] = b;
 473                 data1[x][2] = b;
 474                 data1[x][3] = 255;
 475                 //data2[x][0] = 255 - b;
 476                 //data2[x][1] = 255 - b;
 477                 //data2[x][2] = 255 - b;
 478                 //data2[x][3] = 255;
 479         }
 480         if (r_texture_fogattenuation)
 481         {
 482                 R_UpdateTexture(r_texture_fogattenuation, &data1[0][0], 0, 0, FOGWIDTH, 1);
 483                 //R_UpdateTexture(r_texture_fogattenuation, &data2[0][0], 0, 0, FOGWIDTH, 1);
 484         }
 485         else
 486         {
 487                 r_texture_fogattenuation = R_LoadTexture2D(r_main_texturepool, "fogattenuation", FOGWIDTH, 1, &data1[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT | TEXF_ALLOWUPDATES, -1, NULL);
 488                 //r_texture_fogintensity = R_LoadTexture2D(r_main_texturepool, "fogintensity", FOGWIDTH, 1, &data2[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALLOWUPDATES, NULL);
 489         }
 490 }
 491
 492 static void R_BuildFogHeightTexture(void)
 493 {
 494         unsigned char *inpixels;
 495         int size;
 496         int x;
 497         int y;
 498         int j;
 499         float c[4];
 500         float f;
 501         inpixels = NULL;
 502         strlcpy(r_refdef.fogheighttexturename, r_refdef.fog_height_texturename, sizeof(r_refdef.fogheighttexturename));
 503         if (r_refdef.fogheighttexturename[0])
 504                 inpixels = loadimagepixelsbgra(r_refdef.fogheighttexturename, true, false, false, NULL);
 505         if (!inpixels)
 506         {
 507                 r_refdef.fog_height_tablesize = 0;
 508                 if (r_texture_fogheighttexture)
 509                         R_FreeTexture(r_texture_fogheighttexture);
 510                 r_texture_fogheighttexture = NULL;
 511                 if (r_refdef.fog_height_table2d)
 512                         Mem_Free(r_refdef.fog_height_table2d);
 513                 r_refdef.fog_height_table2d = NULL;
 514                 if (r_refdef.fog_height_table1d)
 515                         Mem_Free(r_refdef.fog_height_table1d);
 516                 r_refdef.fog_height_table1d = NULL;
 517                 return;
 518         }
 519         size = image_width;
 520         r_refdef.fog_height_tablesize = size;
 521         r_refdef.fog_height_table1d = Mem_Alloc(r_main_mempool, size * 4);
 522         r_refdef.fog_height_table2d = Mem_Alloc(r_main_mempool, size * size * 4);
 523         memcpy(r_refdef.fog_height_table1d, inpixels, size * 4);
 524         Mem_Free(inpixels);
 525         // LordHavoc: now the magic - what is that table2d for?  it is a cooked
 526         // average fog color table accounting for every fog layer between a point
 527         // and the camera.  (Note: attenuation is handled separately!)
 528         for (y = 0;y < size;y++)
 529         {
 530                 for (x = 0;x < size;x++)
 531                 {
 532                         Vector4Clear(c);
 533                         f = 0;
 534                         if (x < y)
 535                         {
 536                                 for (j = x;j <= y;j++)
 537                                 {
 538                                         Vector4Add(c, r_refdef.fog_height_table1d + j*4, c);
 539                                         f++;
 540                                 }
 541                         }
 542                         else
 543                         {
 544                                 for (j = x;j >= y;j--)
 545                                 {
 546                                         Vector4Add(c, r_refdef.fog_height_table1d + j*4, c);
 547                                         f++;
 548                                 }
 549                         }
 550                         f = 1.0f / f;
 551                         r_refdef.fog_height_table2d[(y*size+x)*4+0] = (unsigned char)(c[0] * f);
 552                         r_refdef.fog_height_table2d[(y*size+x)*4+1] = (unsigned char)(c[1] * f);
 553                         r_refdef.fog_height_table2d[(y*size+x)*4+2] = (unsigned char)(c[2] * f);
 554                         r_refdef.fog_height_table2d[(y*size+x)*4+3] = (unsigned char)(c[3] * f);
 555                 }
 556         }
 557         r_texture_fogheighttexture = R_LoadTexture2D(r_main_texturepool, "fogheighttable", size, size, r_refdef.fog_height_table2d, TEXTYPE_BGRA, TEXF_ALPHA | TEXF_CLAMP, -1, NULL);
 558 }
 559
 560 //=======================================================================================================================================================
 561
 562 static const char *builtinshaderstring =
 563 "// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
 564 "// written by Forest 'LordHavoc' Hale\n"
 565 "// shadowmapping enhancements by Lee 'eihrul' Salzman\n"
 566 "\n"
 567 "#if defined(USEFOGINSIDE) || defined(USEFOGOUTSIDE) || defined(USEFOGHEIGHTTEXTURE)\n"
 568 "# define USEFOG\n"
 569 "#endif\n"
 570 "#if defined(MODE_LIGHTMAP) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
 571 "#define USELIGHTMAP\n"
 572 "#endif\n"
 573 "#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE)\n"
 574 "#define USEEYEVECTOR\n"
 575 "#endif\n"
 576 "\n"
 577 "#if defined(USESHADOWMAPRECT) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USEDEFERREDLIGHTMAP)\n"
 578 "# extension GL_ARB_texture_rectangle : enable\n"
 579 "#endif\n"
 580 "\n"
 581 "#ifdef USESHADOWMAP2D\n"
 582 "# ifdef GL_EXT_gpu_shader4\n"
 583 "#   extension GL_EXT_gpu_shader4 : enable\n"
 584 "# endif\n"
 585 "# ifdef GL_ARB_texture_gather\n"
 586 "#   extension GL_ARB_texture_gather : enable\n"
 587 "# else\n"
 588 "#   ifdef GL_AMD_texture_texture4\n"
 589 "#     extension GL_AMD_texture_texture4 : enable\n"
 590 "#   endif\n"
 591 "# endif\n"
 592 "#endif\n"
 593 "\n"
 594 "#ifdef USESHADOWMAPCUBE\n"
 595 "# extension GL_EXT_gpu_shader4 : enable\n"
 596 "#endif\n"
 597 "\n"
 598 "//#ifdef USESHADOWSAMPLER\n"
 599 "//# extension GL_ARB_shadow : enable\n"
 600 "//#endif\n"
 601 "\n"
 602 "//#ifdef __GLSL_CG_DATA_TYPES\n"
 603 "//# define myhalf half\n"
 604 "//# define myhalf2 half2\n"
 605 "//# define myhalf3 half3\n"
 606 "//# define myhalf4 half4\n"
 607 "//#else\n"
 608 "# define myhalf float\n"
 609 "# define myhalf2 vec2\n"
 610 "# define myhalf3 vec3\n"
 611 "# define myhalf4 vec4\n"
 612 "//#endif\n"
 613 "\n"
 614 "#ifdef VERTEX_SHADER\n"
 615 "uniform mat4 ModelViewProjectionMatrix;\n"
 616 "#endif\n"
 617 "\n"
 618 "#ifdef MODE_DEPTH_OR_SHADOW\n"
 619 "#ifdef VERTEX_SHADER\n"
 620 "void main(void)\n"
 621 "{\n"
 622 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 623 "}\n"
 624 "#endif\n"
 625 "#else // !MODE_DEPTH_ORSHADOW\n"
 626 "\n"
 627 "\n"
 628 "\n"
 629 "\n"
 630 "#ifdef MODE_SHOWDEPTH\n"
 631 "#ifdef VERTEX_SHADER\n"
 632 "void main(void)\n"
 633 "{\n"
 634 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 635 "       gl_FrontColor = vec4(gl_Position.z, gl_Position.z, gl_Position.z, 1.0);\n"
 636 "}\n"
 637 "#endif\n"
 638 "\n"
 639 "#ifdef FRAGMENT_SHADER\n"
 640 "void main(void)\n"
 641 "{\n"
 642 "       gl_FragColor = gl_Color;\n"
 643 "}\n"
 644 "#endif\n"
 645 "#else // !MODE_SHOWDEPTH\n"
 646 "\n"
 647 "\n"
 648 "\n"
 649 "\n"
 650 "#ifdef MODE_POSTPROCESS\n"
 651 "varying vec2 TexCoord1;\n"
 652 "varying vec2 TexCoord2;\n"
 653 "\n"
 654 "#ifdef VERTEX_SHADER\n"
 655 "void main(void)\n"
 656 "{\n"
 657 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 658 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
 659 "#ifdef USEBLOOM\n"
 660 "       TexCoord2 = gl_MultiTexCoord1.xy;\n"
 661 "#endif\n"
 662 "}\n"
 663 "#endif\n"
 664 "\n"
 665 "#ifdef FRAGMENT_SHADER\n"
 666 "uniform sampler2D Texture_First;\n"
 667 "#ifdef USEBLOOM\n"
 668 "uniform sampler2D Texture_Second;\n"
 669 "#endif\n"
 670 "#ifdef USEGAMMARAMPS\n"
 671 "uniform sampler2D Texture_GammaRamps;\n"
 672 "#endif\n"
 673 "#ifdef USESATURATION\n"
 674 "uniform float Saturation;\n"
 675 "#endif\n"
 676 "#ifdef USEVIEWTINT\n"
 677 "uniform vec4 ViewTintColor;\n"
 678 "#endif\n"
 679 "//uncomment these if you want to use them:\n"
 680 "uniform vec4 UserVec1;\n"
 681 "uniform vec4 UserVec2;\n"
 682 "// uniform vec4 UserVec3;\n"
 683 "// uniform vec4 UserVec4;\n"
 684 "// uniform float ClientTime;\n"
 685 "uniform vec2 PixelSize;\n"
 686 "void main(void)\n"
 687 "{\n"
 688 "       gl_FragColor = texture2D(Texture_First, TexCoord1);\n"
 689 "#ifdef USEBLOOM\n"
 690 "       gl_FragColor += texture2D(Texture_Second, TexCoord2);\n"
 691 "#endif\n"
 692 "#ifdef USEVIEWTINT\n"
 693 "       gl_FragColor = mix(gl_FragColor, ViewTintColor, ViewTintColor.a);\n"
 694 "#endif\n"
 695 "\n"
 696 "#ifdef USEPOSTPROCESSING\n"
 697 "// do r_glsl_dumpshader, edit glsl/default.glsl, and replace this by your own postprocessing if you want\n"
 698 "// 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"
 699 "       float sobel = 1.0;\n"
 700 "       // vec2 ts = textureSize(Texture_First, 0);\n"
 701 "       // vec2 px = vec2(1/ts.x, 1/ts.y);\n"
 702 "       vec2 px = PixelSize;\n"
 703 "       vec3 x1 = texture2D(Texture_First, TexCoord1 + vec2(-px.x, px.y)).rgb;\n"
 704 "       vec3 x2 = texture2D(Texture_First, TexCoord1 + vec2(-px.x,  0.0)).rgb;\n"
 705 "       vec3 x3 = texture2D(Texture_First, TexCoord1 + vec2(-px.x,-px.y)).rgb;\n"
 706 "       vec3 x4 = texture2D(Texture_First, TexCoord1 + vec2( px.x, px.y)).rgb;\n"
 707 "       vec3 x5 = texture2D(Texture_First, TexCoord1 + vec2( px.x,  0.0)).rgb;\n"
 708 "       vec3 x6 = texture2D(Texture_First, TexCoord1 + vec2( px.x,-px.y)).rgb;\n"
 709 "       vec3 y1 = texture2D(Texture_First, TexCoord1 + vec2( px.x,-px.y)).rgb;\n"
 710 "       vec3 y2 = texture2D(Texture_First, TexCoord1 + vec2(  0.0,-px.y)).rgb;\n"
 711 "       vec3 y3 = texture2D(Texture_First, TexCoord1 + vec2(-px.x,-px.y)).rgb;\n"
 712 "       vec3 y4 = texture2D(Texture_First, TexCoord1 + vec2( px.x, px.y)).rgb;\n"
 713 "       vec3 y5 = texture2D(Texture_First, TexCoord1 + vec2(  0.0, px.y)).rgb;\n"
 714 "       vec3 y6 = texture2D(Texture_First, TexCoord1 + vec2(-px.x, px.y)).rgb;\n"
 715 "       float px1 = -1.0 * dot(vec3(0.3, 0.59, 0.11), x1);\n"
 716 "       float px2 = -2.0 * dot(vec3(0.3, 0.59, 0.11), x2);\n"
 717 "       float px3 = -1.0 * dot(vec3(0.3, 0.59, 0.11), x3);\n"
 718 "       float px4 =  1.0 * dot(vec3(0.3, 0.59, 0.11), x4);\n"
 719 "       float px5 =  2.0 * dot(vec3(0.3, 0.59, 0.11), x5);\n"
 720 "       float px6 =  1.0 * dot(vec3(0.3, 0.59, 0.11), x6);\n"
 721 "       float py1 = -1.0 * dot(vec3(0.3, 0.59, 0.11), y1);\n"
 722 "       float py2 = -2.0 * dot(vec3(0.3, 0.59, 0.11), y2);\n"
 723 "       float py3 = -1.0 * dot(vec3(0.3, 0.59, 0.11), y3);\n"
 724 "       float py4 =  1.0 * dot(vec3(0.3, 0.59, 0.11), y4);\n"
 725 "       float py5 =  2.0 * dot(vec3(0.3, 0.59, 0.11), y5);\n"
 726 "       float py6 =  1.0 * dot(vec3(0.3, 0.59, 0.11), y6);\n"
 727 "       sobel = 0.25 * abs(px1 + px2 + px3 + px4 + px5 + px6) + 0.25 * abs(py1 + py2 + py3 + py4 + py5 + py6);\n"
 728 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.987688, -0.156434)) * UserVec1.y;\n"
 729 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.156434, -0.891007)) * UserVec1.y;\n"
 730 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2( 0.891007, -0.453990)) * UserVec1.y;\n"
 731 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2( 0.707107,  0.707107)) * UserVec1.y;\n"
 732 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.453990,  0.891007)) * UserVec1.y;\n"
 733 "       gl_FragColor /= (1.0 + 5.0 * UserVec1.y);\n"
 734 "       gl_FragColor.rgb = gl_FragColor.rgb * (1.0 + UserVec2.x) + vec3(max(0.0, sobel - UserVec2.z))*UserVec2.y;\n"
 735 "#endif\n"
 736 "\n"
 737 "#ifdef USESATURATION\n"
 738 "       //apply saturation BEFORE gamma ramps, so v_glslgamma value does not matter\n"
 739 "       float y = dot(gl_FragColor.rgb, vec3(0.299, 0.587, 0.114));\n"
 740 "       //gl_FragColor = vec3(y) + (gl_FragColor.rgb - vec3(y)) * Saturation;\n"
 741 "       gl_FragColor.rgb = mix(vec3(y), gl_FragColor.rgb, Saturation);\n"
 742 "#endif\n"
 743 "\n"
 744 "#ifdef USEGAMMARAMPS\n"
 745 "       gl_FragColor.r = texture2D(Texture_GammaRamps, vec2(gl_FragColor.r, 0)).r;\n"
 746 "       gl_FragColor.g = texture2D(Texture_GammaRamps, vec2(gl_FragColor.g, 0)).g;\n"
 747 "       gl_FragColor.b = texture2D(Texture_GammaRamps, vec2(gl_FragColor.b, 0)).b;\n"
 748 "#endif\n"
 749 "}\n"
 750 "#endif\n"
 751 "#else // !MODE_POSTPROCESS\n"
 752 "\n"
 753 "\n"
 754 "\n"
 755 "\n"
 756 "#ifdef MODE_GENERIC\n"
 757 "#ifdef USEDIFFUSE\n"
 758 "varying vec2 TexCoord1;\n"
 759 "#endif\n"
 760 "#ifdef USESPECULAR\n"
 761 "varying vec2 TexCoord2;\n"
 762 "#endif\n"
 763 "#ifdef VERTEX_SHADER\n"
 764 "void main(void)\n"
 765 "{\n"
 766 "       gl_FrontColor = gl_Color;\n"
 767 "#ifdef USEDIFFUSE\n"
 768 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
 769 "#endif\n"
 770 "#ifdef USESPECULAR\n"
 771 "       TexCoord2 = gl_MultiTexCoord1.xy;\n"
 772 "#endif\n"
 773 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 774 "}\n"
 775 "#endif\n"
 776 "\n"
 777 "#ifdef FRAGMENT_SHADER\n"
 778 "#ifdef USEDIFFUSE\n"
 779 "uniform sampler2D Texture_First;\n"
 780 "#endif\n"
 781 "#ifdef USESPECULAR\n"
 782 "uniform sampler2D Texture_Second;\n"
 783 "#endif\n"
 784 "\n"
 785 "void main(void)\n"
 786 "{\n"
 787 "       gl_FragColor = gl_Color;\n"
 788 "#ifdef USEDIFFUSE\n"
 789 "       gl_FragColor *= texture2D(Texture_First, TexCoord1);\n"
 790 "#endif\n"
 791 "\n"
 792 "#ifdef USESPECULAR\n"
 793 "       vec4 tex2 = texture2D(Texture_Second, TexCoord2);\n"
 794 "# ifdef USECOLORMAPPING\n"
 795 "       gl_FragColor *= tex2;\n"
 796 "# endif\n"
 797 "# ifdef USEGLOW\n"
 798 "       gl_FragColor += tex2;\n"
 799 "# endif\n"
 800 "# ifdef USEVERTEXTEXTUREBLEND\n"
 801 "       gl_FragColor = mix(gl_FragColor, tex2, tex2.a);\n"
 802 "# endif\n"
 803 "#endif\n"
 804 "}\n"
 805 "#endif\n"
 806 "#else // !MODE_GENERIC\n"
 807 "\n"
 808 "\n"
 809 "\n"
 810 "\n"
 811 "#ifdef MODE_BLOOMBLUR\n"
 812 "varying TexCoord;\n"
 813 "#ifdef VERTEX_SHADER\n"
 814 "void main(void)\n"
 815 "{\n"
 816 "       gl_FrontColor = gl_Color;\n"
 817 "       TexCoord = gl_MultiTexCoord0.xy;\n"
 818 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 819 "}\n"
 820 "#endif\n"
 821 "\n"
 822 "#ifdef FRAGMENT_SHADER\n"
 823 "uniform sampler2D Texture_First;\n"
 824 "uniform vec4 BloomBlur_Parameters;\n"
 825 "\n"
 826 "void main(void)\n"
 827 "{\n"
 828 "       int i;\n"
 829 "       vec2 tc = TexCoord;\n"
 830 "       vec3 color = texture2D(Texture_First, tc).rgb;\n"
 831 "       tc += BloomBlur_Parameters.xy;\n"
 832 "       for (i = 1;i < SAMPLES;i++)\n"
 833 "       {\n"
 834 "               color += texture2D(Texture_First, tc).rgb;\n"
 835 "               tc += BloomBlur_Parameters.xy;\n"
 836 "       }\n"
 837 "       gl_FragColor = vec4(color * BloomBlur_Parameters.z + vec3(BloomBlur_Parameters.w), 1);\n"
 838 "}\n"
 839 "#endif\n"
 840 "#else // !MODE_BLOOMBLUR\n"
 841 "#ifdef MODE_REFRACTION\n"
 842 "varying vec2 TexCoord;\n"
 843 "varying vec4 ModelViewProjectionPosition;\n"
 844 "uniform mat4 TexMatrix;\n"
 845 "#ifdef VERTEX_SHADER\n"
 846 "\n"
 847 "void main(void)\n"
 848 "{\n"
 849 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
 850 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 851 "       ModelViewProjectionPosition = gl_Position;\n"
 852 "}\n"
 853 "#endif\n"
 854 "\n"
 855 "#ifdef FRAGMENT_SHADER\n"
 856 "uniform sampler2D Texture_Normal;\n"
 857 "uniform sampler2D Texture_Refraction;\n"
 858 "uniform sampler2D Texture_Reflection;\n"
 859 "\n"
 860 "uniform vec4 DistortScaleRefractReflect;\n"
 861 "uniform vec4 ScreenScaleRefractReflect;\n"
 862 "uniform vec4 ScreenCenterRefractReflect;\n"
 863 "uniform vec4 RefractColor;\n"
 864 "uniform vec4 ReflectColor;\n"
 865 "uniform float ReflectFactor;\n"
 866 "uniform float ReflectOffset;\n"
 867 "\n"
 868 "void main(void)\n"
 869 "{\n"
 870 "       vec2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
 871 "       //vec2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
 872 "       vec2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
 873 "       vec2 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xy * DistortScaleRefractReflect.xy;\n"
 874 "       // FIXME temporary hack to detect the case that the reflection\n"
 875 "       // gets blackened at edges due to leaving the area that contains actual\n"
 876 "       // content.\n"
 877 "       // Remove this 'ack once we have a better way to stop this thing from\n"
 878 "       // 'appening.\n"
 879 "       float f = min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(0.01, 0.01)).rgb) / 0.05);\n"
 880 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(0.01, -0.01)).rgb) / 0.05);\n"
 881 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
 882 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
 883 "       ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n"
 884 "       gl_FragColor = texture2D(Texture_Refraction, ScreenTexCoord) * RefractColor;\n"
 885 "}\n"
 886 "#endif\n"
 887 "#else // !MODE_REFRACTION\n"
 888 "\n"
 889 "\n"
 890 "\n"
 891 "\n"
 892 "#ifdef MODE_WATER\n"
 893 "varying vec2 TexCoord;\n"
 894 "varying vec3 EyeVector;\n"
 895 "varying vec4 ModelViewProjectionPosition;\n"
 896 "#ifdef VERTEX_SHADER\n"
 897 "uniform vec3 EyePosition;\n"
 898 "uniform mat4 TexMatrix;\n"
 899 "\n"
 900 "void main(void)\n"
 901 "{\n"
 902 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
 903 "       vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
 904 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
 905 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
 906 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
 907 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 908 "       ModelViewProjectionPosition = gl_Position;\n"
 909 "}\n"
 910 "#endif\n"
 911 "\n"
 912 "#ifdef FRAGMENT_SHADER\n"
 913 "uniform sampler2D Texture_Normal;\n"
 914 "uniform sampler2D Texture_Refraction;\n"
 915 "uniform sampler2D Texture_Reflection;\n"
 916 "\n"
 917 "uniform vec4 DistortScaleRefractReflect;\n"
 918 "uniform vec4 ScreenScaleRefractReflect;\n"
 919 "uniform vec4 ScreenCenterRefractReflect;\n"
 920 "uniform vec4 RefractColor;\n"
 921 "uniform vec4 ReflectColor;\n"
 922 "uniform float ReflectFactor;\n"
 923 "uniform float ReflectOffset;\n"
 924 "\n"
 925 "void main(void)\n"
 926 "{\n"
 927 "       vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
 928 "       //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
 929 "       vec4 SafeScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
 930 "       //SafeScreenTexCoord = gl_FragCoord.xyxy * vec4(1.0 / 1920.0, 1.0 / 1200.0, 1.0 / 1920.0, 1.0 / 1200.0);\n"
 931 "       vec4 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
 932 "       // FIXME temporary hack to detect the case that the reflection\n"
 933 "       // gets blackened at edges due to leaving the area that contains actual\n"
 934 "       // content.\n"
 935 "       // Remove this 'ack once we have a better way to stop this thing from\n"
 936 "       // 'appening.\n"
 937 "       float f = min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.01, 0.01)).rgb) / 0.05);\n"
 938 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.01, -0.01)).rgb) / 0.05);\n"
 939 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
 940 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
 941 "       ScreenTexCoord.xy = mix(SafeScreenTexCoord.xy, ScreenTexCoord.xy, f);\n"
 942 "       f       = min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.01, 0.01)).rgb) / 0.05);\n"
 943 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.01, -0.01)).rgb) / 0.05);\n"
 944 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
 945 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
 946 "       ScreenTexCoord.zw = mix(SafeScreenTexCoord.zw, ScreenTexCoord.zw, f);\n"
 947 "       float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 2.0) * ReflectFactor + ReflectOffset;\n"
 948 "       gl_FragColor = mix(texture2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, texture2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n"
 949 "}\n"
 950 "#endif\n"
 951 "#else // !MODE_WATER\n"
 952 "\n"
 953 "\n"
 954 "\n"
 955 "\n"
 956 "// common definitions between vertex shader and fragment shader:\n"
 957 "\n"
 958 "varying vec2 TexCoord;\n"
 959 "#ifdef USEVERTEXTEXTUREBLEND\n"
 960 "varying vec2 TexCoord2;\n"
 961 "#endif\n"
 962 "#ifdef USELIGHTMAP\n"
 963 "varying vec2 TexCoordLightmap;\n"
 964 "#endif\n"
 965 "\n"
 966 "#ifdef MODE_LIGHTSOURCE\n"
 967 "varying vec3 CubeVector;\n"
 968 "#endif\n"
 969 "\n"
 970 "#if (defined(MODE_LIGHTSOURCE) || defined(MODE_LIGHTDIRECTION)) && defined(USEDIFFUSE)\n"
 971 "varying vec3 LightVector;\n"
 972 "#endif\n"
 973 "\n"
 974 "#ifdef USEEYEVECTOR\n"
 975 "varying vec3 EyeVector;\n"
 976 "#endif\n"
 977 "#ifdef USEFOG\n"
 978 "varying vec4 EyeVectorModelSpaceFogPlaneVertexDist;\n"
 979 "#endif\n"
 980 "\n"
 981 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n"
 982 "varying vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n"
 983 "varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
 984 "varying vec3 VectorR; // direction of R texcoord (surface normal)\n"
 985 "#endif\n"
 986 "\n"
 987 "#ifdef USEREFLECTION\n"
 988 "varying vec4 ModelViewProjectionPosition;\n"
 989 "#endif\n"
 990 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
 991 "uniform vec3 LightPosition;\n"
 992 "varying vec4 ModelViewPosition;\n"
 993 "#endif\n"
 994 "\n"
 995 "#ifdef MODE_LIGHTSOURCE\n"
 996 "uniform vec3 LightPosition;\n"
 997 "#endif\n"
 998 "uniform vec3 EyePosition;\n"
 999 "#ifdef MODE_LIGHTDIRECTION\n"
1000 "uniform vec3 LightDir;\n"
1001 "#endif\n"
1002 "uniform vec4 FogPlane;\n"
1003 "\n"
1004 "#ifdef USESHADOWMAPORTHO\n"
1005 "varying vec3 ShadowMapTC;\n"
1006 "#endif\n"
1007 "\n"
1008 "\n"
1009 "\n"
1010 "\n"
1011 "\n"
1012 "// 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"
1013 "\n"
1014 "// fragment shader specific:\n"
1015 "#ifdef FRAGMENT_SHADER\n"
1016 "\n"
1017 "uniform sampler2D Texture_Normal;\n"
1018 "uniform sampler2D Texture_Color;\n"
1019 "uniform sampler2D Texture_Gloss;\n"
1020 "#ifdef USEGLOW\n"
1021 "uniform sampler2D Texture_Glow;\n"
1022 "#endif\n"
1023 "#ifdef USEVERTEXTEXTUREBLEND\n"
1024 "uniform sampler2D Texture_SecondaryNormal;\n"
1025 "uniform sampler2D Texture_SecondaryColor;\n"
1026 "uniform sampler2D Texture_SecondaryGloss;\n"
1027 "#ifdef USEGLOW\n"
1028 "uniform sampler2D Texture_SecondaryGlow;\n"
1029 "#endif\n"
1030 "#endif\n"
1031 "#ifdef USECOLORMAPPING\n"
1032 "uniform sampler2D Texture_Pants;\n"
1033 "uniform sampler2D Texture_Shirt;\n"
1034 "#endif\n"
1035 "#ifdef USEFOG\n"
1036 "#ifdef USEFOGHEIGHTTEXTURE\n"
1037 "uniform sampler2D Texture_FogHeightTexture;\n"
1038 "#endif\n"
1039 "uniform sampler2D Texture_FogMask;\n"
1040 "#endif\n"
1041 "#ifdef USELIGHTMAP\n"
1042 "uniform sampler2D Texture_Lightmap;\n"
1043 "#endif\n"
1044 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
1045 "uniform sampler2D Texture_Deluxemap;\n"
1046 "#endif\n"
1047 "#ifdef USEREFLECTION\n"
1048 "uniform sampler2D Texture_Reflection;\n"
1049 "#endif\n"
1050 "\n"
1051 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
1052 "uniform sampler2D Texture_ScreenDepth;\n"
1053 "uniform sampler2D Texture_ScreenNormalMap;\n"
1054 "#endif\n"
1055 "#ifdef USEDEFERREDLIGHTMAP\n"
1056 "uniform sampler2D Texture_ScreenDiffuse;\n"
1057 "uniform sampler2D Texture_ScreenSpecular;\n"
1058 "#endif\n"
1059 "\n"
1060 "uniform myhalf3 Color_Pants;\n"
1061 "uniform myhalf3 Color_Shirt;\n"
1062 "uniform myhalf3 FogColor;\n"
1063 "\n"
1064 "#ifdef USEFOG\n"
1065 "uniform float FogRangeRecip;\n"
1066 "uniform float FogPlaneViewDist;\n"
1067 "uniform float FogHeightFade;\n"
1068 "vec3 FogVertex(vec3 surfacecolor)\n"
1069 "{\n"
1070 "       vec3 EyeVectorModelSpace = EyeVectorModelSpaceFogPlaneVertexDist.xyz;\n"
1071 "       float FogPlaneVertexDist = EyeVectorModelSpaceFogPlaneVertexDist.w;\n"
1072 "       float fogfrac;\n"
1073 "#ifdef USEFOGHEIGHTTEXTURE\n"
1074 "       vec4 fogheightpixel = texture2D(Texture_FogHeightTexture, vec2(1,1) + vec2(FogPlaneVertexDist, FogPlaneViewDist) * (-2.0 * FogHeightFade));\n"
1075 "       fogfrac = fogheightpixel.a;\n"
1076 "       return mix(fogheightpixel.rgb * FogColor, surfacecolor, texture2D(Texture_FogMask, myhalf2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
1077 "#else\n"
1078 "# ifdef USEFOGOUTSIDE\n"
1079 "       fogfrac = min(0.0, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0, min(0.0, FogPlaneVertexDist) * FogHeightFade);\n"
1080 "# else\n"
1081 "       fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0, FogPlaneVertexDist)) * min(1.0, (min(0.0, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);\n"
1082 "# endif\n"
1083 "       return mix(FogColor, surfacecolor, texture2D(Texture_FogMask, myhalf2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
1084 "#endif\n"
1085 "}\n"
1086 "#endif\n"
1087 "\n"
1088 "#ifdef USEOFFSETMAPPING\n"
1089 "uniform float OffsetMapping_Scale;\n"
1090 "vec2 OffsetMapping(vec2 TexCoord)\n"
1091 "{\n"
1092 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
1093 "       // 14 sample relief mapping: linear search and then binary search\n"
1094 "       // this basically steps forward a small amount repeatedly until it finds\n"
1095 "       // itself inside solid, then jitters forward and back using decreasing\n"
1096 "       // amounts to find the impact\n"
1097 "       //vec3 OffsetVector = vec3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1), -1);\n"
1098 "       //vec3 OffsetVector = vec3(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
1099 "       vec3 OffsetVector = vec3(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
1100 "       vec3 RT = vec3(TexCoord, 1);\n"
1101 "       OffsetVector *= 0.1;\n"
1102 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1103 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1104 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1105 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1106 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1107 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1108 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1109 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1110 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1111 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z)          - 0.5);\n"
1112 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.5    - 0.25);\n"
1113 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.25   - 0.125);\n"
1114 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.125  - 0.0625);\n"
1115 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
1116 "       return RT.xy;\n"
1117 "#else\n"
1118 "       // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
1119 "       // this basically moves forward the full distance, and then backs up based\n"
1120 "       // on height of samples\n"
1121 "       //vec2 OffsetVector = vec2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1));\n"
1122 "       //vec2 OffsetVector = vec2(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1));\n"
1123 "       vec2 OffsetVector = vec2(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1));\n"
1124 "       TexCoord += OffsetVector;\n"
1125 "       OffsetVector *= 0.333;\n"
1126 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1127 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1128 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1129 "       return TexCoord;\n"
1130 "#endif\n"
1131 "}\n"
1132 "#endif // USEOFFSETMAPPING\n"
1133 "\n"
1134 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n"
1135 "uniform sampler2D Texture_Attenuation;\n"
1136 "uniform samplerCube Texture_Cube;\n"
1137 "#endif\n"
1138 "\n"
1139 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n"
1140 "\n"
1141 "#ifdef USESHADOWMAPRECT\n"
1142 "# ifdef USESHADOWSAMPLER\n"
1143 "uniform sampler2DRectShadow Texture_ShadowMapRect;\n"
1144 "# else\n"
1145 "uniform sampler2DRect Texture_ShadowMapRect;\n"
1146 "# endif\n"
1147 "#endif\n"
1148 "\n"
1149 "#ifdef USESHADOWMAP2D\n"
1150 "# ifdef USESHADOWSAMPLER\n"
1151 "uniform sampler2DShadow Texture_ShadowMap2D;\n"
1152 "# else\n"
1153 "uniform sampler2D Texture_ShadowMap2D;\n"
1154 "# endif\n"
1155 "#endif\n"
1156 "\n"
1157 "#ifdef USESHADOWMAPVSDCT\n"
1158 "uniform samplerCube Texture_CubeProjection;\n"
1159 "#endif\n"
1160 "\n"
1161 "#ifdef USESHADOWMAPCUBE\n"
1162 "# ifdef USESHADOWSAMPLER\n"
1163 "uniform samplerCubeShadow Texture_ShadowMapCube;\n"
1164 "# else\n"
1165 "uniform samplerCube Texture_ShadowMapCube;\n"
1166 "# endif\n"
1167 "#endif\n"
1168 "\n"
1169 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D) || defined(USESHADOWMAPCUBE)\n"
1170 "uniform vec2 ShadowMap_TextureScale;\n"
1171 "uniform vec4 ShadowMap_Parameters;\n"
1172 "#endif\n"
1173 "\n"
1174 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n"
1175 "# ifdef USESHADOWMAPORTHO\n"
1176 "#  define GetShadowMapTC2D(dir) (min(dir, ShadowMap_Parameters.xyz))\n"
1177 "# else\n"
1178 "#  ifdef USESHADOWMAPVSDCT\n"
1179 "vec3 GetShadowMapTC2D(vec3 dir)\n"
1180 "{\n"
1181 "       vec3 adir = abs(dir);\n"
1182 "       vec2 aparams = ShadowMap_Parameters.xy / max(max(adir.x, adir.y), adir.z);\n"
1183 "       vec4 proj = textureCube(Texture_CubeProjection, dir);\n"
1184 "       return vec3(mix(dir.xy, dir.zz, proj.xy) * aparams.x + proj.zw * ShadowMap_Parameters.z, aparams.y + ShadowMap_Parameters.w);\n"
1185 "}\n"
1186 "#  else\n"
1187 "vec3 GetShadowMapTC2D(vec3 dir)\n"
1188 "{\n"
1189 "       vec3 adir = abs(dir);\n"
1190 "       float ma = adir.z;\n"
1191 "       vec4 proj = vec4(dir, 2.5);\n"
1192 "       if (adir.x > ma) { ma = adir.x; proj = vec4(dir.zyx, 0.5); }\n"
1193 "       if (adir.y > ma) { ma = adir.y; proj = vec4(dir.xzy, 1.5); }\n"
1194 "       vec2 aparams = ShadowMap_Parameters.xy / ma;\n"
1195 "       return vec3(proj.xy * aparams.x + vec2(proj.z < 0.0 ? 1.5 : 0.5, proj.w) * ShadowMap_Parameters.z, aparams.y + ShadowMap_Parameters.w);\n"
1196 "}\n"
1197 "#  endif\n"
1198 "# endif\n"
1199 "#endif // defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n"
1200 "\n"
1201 "#ifdef USESHADOWMAPCUBE\n"
1202 "vec4 GetShadowMapTCCube(vec3 dir)\n"
1203 "{\n"
1204 "       vec3 adir = abs(dir);\n"
1205 "       return vec4(dir, ShadowMap_Parameters.w + ShadowMap_Parameters.y / max(max(adir.x, adir.y), adir.z));\n"
1206 "}\n"
1207 "#endif\n"
1208 "\n"
1209 "# ifdef USESHADOWMAPRECT\n"
1210 "float ShadowMapCompare(vec3 dir)\n"
1211 "{\n"
1212 "       vec3 shadowmaptc = GetShadowMapTC2D(dir);\n"
1213 "       float f;\n"
1214 "#  ifdef USESHADOWSAMPLER\n"
1215 "\n"
1216 "#    ifdef USESHADOWMAPPCF\n"
1217 "#      define texval(x, y) shadow2DRect(Texture_ShadowMapRect, shadowmaptc + vec3(x, y, 0.0)).r\n"
1218 "       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"
1219 "#    else\n"
1220 "       f = shadow2DRect(Texture_ShadowMapRect, shadowmaptc).r;\n"
1221 "#    endif\n"
1222 "\n"
1223 "#  else\n"
1224 "\n"
1225 "#    ifdef USESHADOWMAPPCF\n"
1226 "#      if USESHADOWMAPPCF > 1\n"
1227 "#        define texval(x, y) texture2DRect(Texture_ShadowMapRect, center + vec2(x, y)).r\n"
1228 "       vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n"
1229 "       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"
1230 "       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"
1231 "       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"
1232 "       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"
1233 "       vec4 cols = row2 + row3 + mix(row1, row4, offset.y);\n"
1234 "       f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
1235 "#      else\n"
1236 "#        define texval(x, y) texture2DRect(Texture_ShadowMapRect, shadowmaptc.xy + vec2(x, y)).r\n"
1237 "       vec2 offset = fract(shadowmaptc.xy);\n"
1238 "       vec3 row1 = step(shadowmaptc.z, vec3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
1239 "       vec3 row2 = step(shadowmaptc.z, vec3(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0)));\n"
1240 "       vec3 row3 = step(shadowmaptc.z, vec3(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0)));\n"
1241 "       vec3 cols = row2 + mix(row1, row3, offset.y);\n"
1242 "       f = dot(mix(cols.xy, cols.yz, offset.x), vec2(0.25));\n"
1243 "#      endif\n"
1244 "#    else\n"
1245 "       f = step(shadowmaptc.z, texture2DRect(Texture_ShadowMapRect, shadowmaptc.xy).r);\n"
1246 "#    endif\n"
1247 "\n"
1248 "#  endif\n"
1249 "#  ifdef USESHADOWMAPORTHO\n"
1250 "       return mix(ShadowMap_Parameters.w, 1.0, f);\n"
1251 "#  else\n"
1252 "       return f;\n"
1253 "#  endif\n"
1254 "}\n"
1255 "# endif\n"
1256 "\n"
1257 "# ifdef USESHADOWMAP2D\n"
1258 "float ShadowMapCompare(vec3 dir)\n"
1259 "{\n"
1260 "       vec3 shadowmaptc = GetShadowMapTC2D(dir);\n"
1261 "       float f;\n"
1262 "\n"
1263 "#  ifdef USESHADOWSAMPLER\n"
1264 "#    ifdef USESHADOWMAPPCF\n"
1265 "#      define texval(x, y) shadow2D(Texture_ShadowMap2D, vec3(center + vec2(x, y)*ShadowMap_TextureScale, shadowmaptc.z)).r  \n"
1266 "       vec2 center = shadowmaptc.xy*ShadowMap_TextureScale;\n"
1267 "       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"
1268 "#    else\n"
1269 "       f = shadow2D(Texture_ShadowMap2D, vec3(shadowmaptc.xy*ShadowMap_TextureScale, shadowmaptc.z)).r;\n"
1270 "#    endif\n"
1271 "#  else\n"
1272 "#    ifdef USESHADOWMAPPCF\n"
1273 "#     if defined(GL_ARB_texture_gather) || defined(GL_AMD_texture_texture4)\n"
1274 "#      ifdef GL_ARB_texture_gather\n"
1275 "#        define texval(x, y) textureGatherOffset(Texture_ShadowMap2D, center, ivec2(x, y))\n"
1276 "#      else\n"
1277 "#        define texval(x, y) texture4(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale)\n"
1278 "#      endif\n"
1279 "       vec2 offset = fract(shadowmaptc.xy - 0.5), center = (shadowmaptc.xy - offset)*ShadowMap_TextureScale;\n"
1280 "#      if USESHADOWMAPPCF > 1\n"
1281 "   vec4 group1 = step(shadowmaptc.z, texval(-2.0, -2.0));\n"
1282 "   vec4 group2 = step(shadowmaptc.z, texval( 0.0, -2.0));\n"
1283 "   vec4 group3 = step(shadowmaptc.z, texval( 2.0, -2.0));\n"
1284 "   vec4 group4 = step(shadowmaptc.z, texval(-2.0,  0.0));\n"
1285 "   vec4 group5 = step(shadowmaptc.z, texval( 0.0,  0.0));\n"
1286 "   vec4 group6 = step(shadowmaptc.z, texval( 2.0,  0.0));\n"
1287 "   vec4 group7 = step(shadowmaptc.z, texval(-2.0,  2.0));\n"
1288 "   vec4 group8 = step(shadowmaptc.z, texval( 0.0,  2.0));\n"
1289 "   vec4 group9 = step(shadowmaptc.z, texval( 2.0,  2.0));\n"
1290 "       vec4 locols = vec4(group1.ab, group3.ab);\n"
1291 "       vec4 hicols = vec4(group7.rg, group9.rg);\n"
1292 "       locols.yz += group2.ab;\n"
1293 "       hicols.yz += group8.rg;\n"
1294 "       vec4 midcols = vec4(group1.rg, group3.rg) + vec4(group7.ab, group9.ab) +\n"
1295 "                               vec4(group4.rg, group6.rg) + vec4(group4.ab, group6.ab) +\n"
1296 "                               mix(locols, hicols, offset.y);\n"
1297 "       vec4 cols = group5 + vec4(group2.rg, group8.ab);\n"
1298 "       cols.xyz += mix(midcols.xyz, midcols.yzw, offset.x);\n"
1299 "       f = dot(cols, vec4(1.0/25.0));\n"
1300 "#      else\n"
1301 "       vec4 group1 = step(shadowmaptc.z, texval(-1.0, -1.0));\n"
1302 "       vec4 group2 = step(shadowmaptc.z, texval( 1.0, -1.0));\n"
1303 "       vec4 group3 = step(shadowmaptc.z, texval(-1.0,  1.0));\n"
1304 "       vec4 group4 = step(shadowmaptc.z, texval( 1.0,  1.0));\n"
1305 "       vec4 cols = vec4(group1.rg, group2.rg) + vec4(group3.ab, group4.ab) +\n"
1306 "                               mix(vec4(group1.ab, group2.ab), vec4(group3.rg, group4.rg), offset.y);\n"
1307 "       f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
1308 "#      endif\n"
1309 "#     else\n"
1310 "#      ifdef GL_EXT_gpu_shader4\n"
1311 "#        define texval(x, y) texture2DOffset(Texture_ShadowMap2D, center, ivec2(x, y)).r\n"
1312 "#      else\n"
1313 "#        define texval(x, y) texture2D(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale).r  \n"
1314 "#      endif\n"
1315 "#      if USESHADOWMAPPCF > 1\n"
1316 "       vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n"
1317 "       center *= ShadowMap_TextureScale;\n"
1318 "       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"
1319 "       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"
1320 "       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"
1321 "       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"
1322 "       vec4 cols = row2 + row3 + mix(row1, row4, offset.y);\n"
1323 "       f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
1324 "#      else\n"
1325 "       vec2 center = shadowmaptc.xy*ShadowMap_TextureScale, offset = fract(shadowmaptc.xy);\n"
1326 "       vec3 row1 = step(shadowmaptc.z, vec3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
1327 "       vec3 row2 = step(shadowmaptc.z, vec3(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0)));\n"
1328 "       vec3 row3 = step(shadowmaptc.z, vec3(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0)));\n"
1329 "       vec3 cols = row2 + mix(row1, row3, offset.y);\n"
1330 "       f = dot(mix(cols.xy, cols.yz, offset.x), vec2(0.25));\n"
1331 "#      endif\n"
1332 "#     endif\n"
1333 "#    else\n"
1334 "       f = step(shadowmaptc.z, texture2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale).r);\n"
1335 "#    endif\n"
1336 "#  endif\n"
1337 "#  ifdef USESHADOWMAPORTHO\n"
1338 "       return mix(ShadowMap_Parameters.w, 1.0, f);\n"
1339 "#  else\n"
1340 "       return f;\n"
1341 "#  endif\n"
1342 "}\n"
1343 "# endif\n"
1344 "\n"
1345 "# ifdef USESHADOWMAPCUBE\n"
1346 "float ShadowMapCompare(vec3 dir)\n"
1347 "{\n"
1348 "       // apply depth texture cubemap as light filter\n"
1349 "       vec4 shadowmaptc = GetShadowMapTCCube(dir);\n"
1350 "       float f;\n"
1351 "#  ifdef USESHADOWSAMPLER\n"
1352 "       f = shadowCube(Texture_ShadowMapCube, shadowmaptc).r;\n"
1353 "#  else\n"
1354 "       f = step(shadowmaptc.w, textureCube(Texture_ShadowMapCube, shadowmaptc.xyz).r);\n"
1355 "#  endif\n"
1356 "       return f;\n"
1357 "}\n"
1358 "# endif\n"
1359 "#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n"
1360 "#endif // FRAGMENT_SHADER\n"
1361 "\n"
1362 "\n"
1363 "\n"
1364 "\n"
1365 "#ifdef MODE_DEFERREDGEOMETRY\n"
1366 "#ifdef VERTEX_SHADER\n"
1367 "uniform mat4 TexMatrix;\n"
1368 "#ifdef USEVERTEXTEXTUREBLEND\n"
1369 "uniform mat4 BackgroundTexMatrix;\n"
1370 "#endif\n"
1371 "uniform mat4 ModelViewMatrix;\n"
1372 "void main(void)\n"
1373 "{\n"
1374 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
1375 "#ifdef USEVERTEXTEXTUREBLEND\n"
1376 "       gl_FrontColor = gl_Color;\n"
1377 "       TexCoord2 = vec2(BackgroundTexMatrix * gl_MultiTexCoord0);\n"
1378 "#endif\n"
1379 "\n"
1380 "       // transform unnormalized eye direction into tangent space\n"
1381 "#ifdef USEOFFSETMAPPING\n"
1382 "       vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
1383 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
1384 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
1385 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
1386 "#endif\n"
1387 "\n"
1388 "       VectorS = (ModelViewMatrix * vec4(gl_MultiTexCoord1.xyz, 0)).xyz;\n"
1389 "       VectorT = (ModelViewMatrix * vec4(gl_MultiTexCoord2.xyz, 0)).xyz;\n"
1390 "       VectorR = (ModelViewMatrix * vec4(gl_MultiTexCoord3.xyz, 0)).xyz;\n"
1391 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
1392 "}\n"
1393 "#endif // VERTEX_SHADER\n"
1394 "\n"
1395 "#ifdef FRAGMENT_SHADER\n"
1396 "void main(void)\n"
1397 "{\n"
1398 "#ifdef USEOFFSETMAPPING\n"
1399 "       // apply offsetmapping\n"
1400 "       vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
1401 "#define TexCoord TexCoordOffset\n"
1402 "#endif\n"
1403 "\n"
1404 "#ifdef USEALPHAKILL\n"
1405 "       if (texture2D(Texture_Color, TexCoord).a < 0.5)\n"
1406 "               discard;\n"
1407 "#endif\n"
1408 "\n"
1409 "#ifdef USEVERTEXTEXTUREBLEND\n"
1410 "       float alpha = texture2D(Texture_Color, TexCoord).a;\n"
1411 "       float terrainblend = clamp(float(gl_Color.a) * alpha * 2.0 - 0.5, float(0.0), float(1.0));\n"
1412 "       //float terrainblend = min(float(gl_Color.a) * alpha * 2.0, float(1.0));\n"
1413 "       //float terrainblend = float(gl_Color.a) * alpha > 0.5;\n"
1414 "#endif\n"
1415 "\n"
1416 "#ifdef USEVERTEXTEXTUREBLEND\n"
1417 "       vec3 surfacenormal = mix(vec3(texture2D(Texture_SecondaryNormal, TexCoord2)), vec3(texture2D(Texture_Normal, TexCoord)), terrainblend) - vec3(0.5, 0.5, 0.5);\n"
1418 "       float a = mix(texture2D(Texture_SecondaryGloss, TexCoord2).a, texture2D(Texture_Gloss, TexCoord).a, terrainblend);\n"
1419 "#else\n"
1420 "       vec3 surfacenormal = vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5, 0.5, 0.5);\n"
1421 "       float a = texture2D(Texture_Gloss, TexCoord).a;\n"
1422 "#endif\n"
1423 "\n"
1424 "       gl_FragColor = vec4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR) * 0.5 + vec3(0.5, 0.5, 0.5), a);\n"
1425 "}\n"
1426 "#endif // FRAGMENT_SHADER\n"
1427 "#else // !MODE_DEFERREDGEOMETRY\n"
1428 "\n"
1429 "\n"
1430 "\n"
1431 "\n"
1432 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
1433 "#ifdef VERTEX_SHADER\n"
1434 "uniform mat4 ModelViewMatrix;\n"
1435 "void main(void)\n"
1436 "{\n"
1437 "       ModelViewPosition = ModelViewMatrix * gl_Vertex;\n"
1438 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
1439 "}\n"
1440 "#endif // VERTEX_SHADER\n"
1441 "\n"
1442 "#ifdef FRAGMENT_SHADER\n"
1443 "uniform mat4 ViewToLight;\n"
1444 "// ScreenToDepth = vec2(Far / (Far - Near), Far * Near / (Near - Far));\n"
1445 "uniform vec2 ScreenToDepth;\n"
1446 "uniform myhalf3 DeferredColor_Ambient;\n"
1447 "uniform myhalf3 DeferredColor_Diffuse;\n"
1448 "#ifdef USESPECULAR\n"
1449 "uniform myhalf3 DeferredColor_Specular;\n"
1450 "uniform myhalf SpecularPower;\n"
1451 "#endif\n"
1452 "uniform myhalf2 PixelToScreenTexCoord;\n"
1453 "void main(void)\n"
1454 "{\n"
1455 "       // calculate viewspace pixel position\n"
1456 "       vec2 ScreenTexCoord = gl_FragCoord.xy * PixelToScreenTexCoord;\n"
1457 "       vec3 position;\n"
1458 "       position.z = ScreenToDepth.y / (texture2D(Texture_ScreenDepth, ScreenTexCoord).r + ScreenToDepth.x);\n"
1459 "       position.xy = ModelViewPosition.xy * (position.z / ModelViewPosition.z);\n"
1460 "       // decode viewspace pixel normal\n"
1461 "       myhalf4 normalmap = texture2D(Texture_ScreenNormalMap, ScreenTexCoord);\n"
1462 "       myhalf3 surfacenormal = normalize(normalmap.rgb - myhalf3(0.5,0.5,0.5));\n"
1463 "       // surfacenormal = pixel normal in viewspace\n"
1464 "       // LightVector = pixel to light in viewspace\n"
1465 "       // CubeVector = position in lightspace\n"
1466 "       // eyevector = pixel to view in viewspace\n"
1467 "       vec3 CubeVector = vec3(ViewToLight * vec4(position,1));\n"
1468 "       myhalf fade = myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
1469 "#ifdef USEDIFFUSE\n"
1470 "       // calculate diffuse shading\n"
1471 "       myhalf3 lightnormal = myhalf3(normalize(LightPosition - position));\n"
1472 "       myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1473 "#endif\n"
1474 "#ifdef USESPECULAR\n"
1475 "       // calculate directional shading\n"
1476 "       vec3 eyevector = position * -1.0;\n"
1477 "#  ifdef USEEXACTSPECULARMATH\n"
1478 "       myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower * normalmap.a);\n"
1479 "#  else\n"
1480 "       myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(eyevector)));\n"
1481 "       myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * normalmap.a);\n"
1482 "#  endif\n"
1483 "#endif\n"
1484 "\n"
1485 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAPCUBE) || defined(USESHADOWMAP2D)\n"
1486 "       fade *= ShadowMapCompare(CubeVector);\n"
1487 "#endif\n"
1488 "\n"
1489 "#ifdef USEDIFFUSE\n"
1490 "       gl_FragData[0] = vec4((DeferredColor_Ambient + DeferredColor_Diffuse * diffuse) * fade, 1.0);\n"
1491 "#else\n"
1492 "       gl_FragData[0] = vec4(DeferredColor_Ambient * fade, 1.0);\n"
1493 "#endif\n"
1494 "#ifdef USESPECULAR\n"
1495 "       gl_FragData[1] = vec4(DeferredColor_Specular * (specular * fade), 1.0);\n"
1496 "#else\n"
1497 "       gl_FragData[1] = vec4(0.0, 0.0, 0.0, 1.0);\n"
1498 "#endif\n"
1499 "\n"
1500 "# ifdef USECUBEFILTER\n"
1501 "       vec3 cubecolor = textureCube(Texture_Cube, CubeVector).rgb;\n"
1502 "       gl_FragData[0].rgb *= cubecolor;\n"
1503 "       gl_FragData[1].rgb *= cubecolor;\n"
1504 "# endif\n"
1505 "}\n"
1506 "#endif // FRAGMENT_SHADER\n"
1507 "#else // !MODE_DEFERREDLIGHTSOURCE\n"
1508 "\n"
1509 "\n"
1510 "\n"
1511 "\n"
1512 "#ifdef VERTEX_SHADER\n"
1513 "uniform mat4 TexMatrix;\n"
1514 "#ifdef USEVERTEXTEXTUREBLEND\n"
1515 "uniform mat4 BackgroundTexMatrix;\n"
1516 "#endif\n"
1517 "#ifdef MODE_LIGHTSOURCE\n"
1518 "uniform mat4 ModelToLight;\n"
1519 "#endif\n"
1520 "#ifdef USESHADOWMAPORTHO\n"
1521 "uniform mat4 ShadowMapMatrix;\n"
1522 "#endif\n"
1523 "void main(void)\n"
1524 "{\n"
1525 "#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n"
1526 "       gl_FrontColor = gl_Color;\n"
1527 "#endif\n"
1528 "       // copy the surface texcoord\n"
1529 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
1530 "#ifdef USEVERTEXTEXTUREBLEND\n"
1531 "       TexCoord2 = vec2(BackgroundTexMatrix * gl_MultiTexCoord0);\n"
1532 "#endif\n"
1533 "#ifdef USELIGHTMAP\n"
1534 "       TexCoordLightmap = vec2(gl_MultiTexCoord4);\n"
1535 "#endif\n"
1536 "\n"
1537 "#ifdef MODE_LIGHTSOURCE\n"
1538 "       // transform vertex position into light attenuation/cubemap space\n"
1539 "       // (-1 to +1 across the light box)\n"
1540 "       CubeVector = vec3(ModelToLight * gl_Vertex);\n"
1541 "\n"
1542 "# ifdef USEDIFFUSE\n"
1543 "       // transform unnormalized light direction into tangent space\n"
1544 "       // (we use unnormalized to ensure that it interpolates correctly and then\n"
1545 "       //  normalize it per pixel)\n"
1546 "       vec3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
1547 "       LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
1548 "       LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
1549 "       LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
1550 "# endif\n"
1551 "#endif\n"
1552 "\n"
1553 "#if defined(MODE_LIGHTDIRECTION) && defined(USEDIFFUSE)\n"
1554 "       LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);\n"
1555 "       LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);\n"
1556 "       LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);\n"
1557 "#endif\n"
1558 "\n"
1559 "       // transform unnormalized eye direction into tangent space\n"
1560 "#ifdef USEEYEVECTOR\n"
1561 "       vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
1562 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
1563 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
1564 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
1565 "#endif\n"
1566 "\n"
1567 "#ifdef USEFOG\n"
1568 "       EyeVectorModelSpaceFogPlaneVertexDist.xyz = EyePosition - gl_Vertex.xyz;\n"
1569 "       EyeVectorModelSpaceFogPlaneVertexDist.w = dot(FogPlane, gl_Vertex);\n"
1570 "#endif\n"
1571 "\n"
1572 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(USEREFLECTCUBE)\n"
1573 "       VectorS = gl_MultiTexCoord1.xyz;\n"
1574 "       VectorT = gl_MultiTexCoord2.xyz;\n"
1575 "       VectorR = gl_MultiTexCoord3.xyz;\n"
1576 "#endif\n"
1577 "\n"
1578 "       // transform vertex to camera space, using ftransform to match non-VS rendering\n"
1579 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
1580 "\n"
1581 "#ifdef USESHADOWMAPORTHO\n"
1582 "       ShadowMapTC = vec3(ShadowMapMatrix * gl_Position);\n"
1583 "#endif\n"
1584 "\n"
1585 "#ifdef USEREFLECTION\n"
1586 "       ModelViewProjectionPosition = gl_Position;\n"
1587 "#endif\n"
1588 "}\n"
1589 "#endif // VERTEX_SHADER\n"
1590 "\n"
1591 "\n"
1592 "\n"
1593 "\n"
1594 "#ifdef FRAGMENT_SHADER\n"
1595 "#ifdef USEDEFERREDLIGHTMAP\n"
1596 "uniform myhalf2 PixelToScreenTexCoord;\n"
1597 "uniform myhalf3 DeferredMod_Diffuse;\n"
1598 "uniform myhalf3 DeferredMod_Specular;\n"
1599 "#endif\n"
1600 "uniform myhalf3 Color_Ambient;\n"
1601 "uniform myhalf3 Color_Diffuse;\n"
1602 "uniform myhalf3 Color_Specular;\n"
1603 "uniform myhalf SpecularPower;\n"
1604 "#ifdef USEGLOW\n"
1605 "uniform myhalf3 Color_Glow;\n"
1606 "#endif\n"
1607 "uniform myhalf Alpha;\n"
1608 "#ifdef USEREFLECTION\n"
1609 "uniform vec4 DistortScaleRefractReflect;\n"
1610 "uniform vec4 ScreenScaleRefractReflect;\n"
1611 "uniform vec4 ScreenCenterRefractReflect;\n"
1612 "uniform myhalf4 ReflectColor;\n"
1613 "#endif\n"
1614 "#ifdef USEREFLECTCUBE\n"
1615 "uniform mat4 ModelToReflectCube;\n"
1616 "uniform sampler2D Texture_ReflectMask;\n"
1617 "uniform samplerCube Texture_ReflectCube;\n"
1618 "#endif\n"
1619 "#ifdef MODE_LIGHTDIRECTION\n"
1620 "uniform myhalf3 LightColor;\n"
1621 "#endif\n"
1622 "#ifdef MODE_LIGHTSOURCE\n"
1623 "uniform myhalf3 LightColor;\n"
1624 "#endif\n"
1625 "void main(void)\n"
1626 "{\n"
1627 "#ifdef USEOFFSETMAPPING\n"
1628 "       // apply offsetmapping\n"
1629 "       vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
1630 "#define TexCoord TexCoordOffset\n"
1631 "#endif\n"
1632 "\n"
1633 "       // combine the diffuse textures (base, pants, shirt)\n"
1634 "       myhalf4 color = myhalf4(texture2D(Texture_Color, TexCoord));\n"
1635 "#ifdef USEALPHAKILL\n"
1636 "       if (color.a < 0.5)\n"
1637 "               discard;\n"
1638 "#endif\n"
1639 "       color.a *= Alpha;\n"
1640 "#ifdef USECOLORMAPPING\n"
1641 "       color.rgb += myhalf3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + myhalf3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
1642 "#endif\n"
1643 "#ifdef USEVERTEXTEXTUREBLEND\n"
1644 "       myhalf terrainblend = clamp(myhalf(gl_Color.a) * color.a * 2.0 - 0.5, myhalf(0.0), myhalf(1.0));\n"
1645 "       //myhalf terrainblend = min(myhalf(gl_Color.a) * color.a * 2.0, myhalf(1.0));\n"
1646 "       //myhalf terrainblend = myhalf(gl_Color.a) * color.a > 0.5;\n"
1647 "       color.rgb = mix(myhalf3(texture2D(Texture_SecondaryColor, TexCoord2)), color.rgb, terrainblend);\n"
1648 "       color.a = 1.0;\n"
1649 "       //color = mix(myhalf4(1, 0, 0, 1), color, terrainblend);\n"
1650 "#endif\n"
1651 "\n"
1652 "       // get the surface normal\n"
1653 "#ifdef USEVERTEXTEXTUREBLEND\n"
1654 "       myhalf3 surfacenormal = normalize(mix(myhalf3(texture2D(Texture_SecondaryNormal, TexCoord2)), myhalf3(texture2D(Texture_Normal, TexCoord)), terrainblend) - myhalf3(0.5, 0.5, 0.5));\n"
1655 "#else\n"
1656 "       myhalf3 surfacenormal = normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5, 0.5, 0.5));\n"
1657 "#endif\n"
1658 "\n"
1659 "       // get the material colors\n"
1660 "       myhalf3 diffusetex = color.rgb;\n"
1661 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
1662 "# ifdef USEVERTEXTEXTUREBLEND\n"
1663 "       myhalf4 glosstex = mix(myhalf4(texture2D(Texture_SecondaryGloss, TexCoord2)), myhalf4(texture2D(Texture_Gloss, TexCoord)), terrainblend);\n"
1664 "# else\n"
1665 "       myhalf4 glosstex = myhalf4(texture2D(Texture_Gloss, TexCoord));\n"
1666 "# endif\n"
1667 "#endif\n"
1668 "\n"
1669 "#ifdef USEREFLECTCUBE\n"
1670 "       vec3 TangentReflectVector = reflect(-EyeVector, surfacenormal);\n"
1671 "       vec3 ModelReflectVector = TangentReflectVector.x * VectorS + TangentReflectVector.y * VectorT + TangentReflectVector.z * VectorR;\n"
1672 "       vec3 ReflectCubeTexCoord = vec3(ModelToReflectCube * vec4(ModelReflectVector, 0));\n"
1673 "       diffusetex += myhalf3(texture2D(Texture_ReflectMask, TexCoord)) * myhalf3(textureCube(Texture_ReflectCube, ReflectCubeTexCoord));\n"
1674 "#endif\n"
1675 "\n"
1676 "\n"
1677 "\n"
1678 "\n"
1679 "#ifdef MODE_LIGHTSOURCE\n"
1680 "       // light source\n"
1681 "#ifdef USEDIFFUSE\n"
1682 "       myhalf3 lightnormal = myhalf3(normalize(LightVector));\n"
1683 "       myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1684 "       color.rgb = diffusetex * (Color_Ambient + diffuse * Color_Diffuse);\n"
1685 "#ifdef USESPECULAR\n"
1686 "#ifdef USEEXACTSPECULARMATH\n"
1687 "       myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n"
1688 "#else\n"
1689 "       myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(EyeVector)));\n"
1690 "       myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n"
1691 "#endif\n"
1692 "       color.rgb += glosstex.rgb * (specular * Color_Specular);\n"
1693 "#endif\n"
1694 "#else\n"
1695 "       color.rgb = diffusetex * Color_Ambient;\n"
1696 "#endif\n"
1697 "       color.rgb *= LightColor;\n"
1698 "       color.rgb *= myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
1699 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAPCUBE) || defined(USESHADOWMAP2D)\n"
1700 "       color.rgb *= ShadowMapCompare(CubeVector);\n"
1701 "#endif\n"
1702 "# ifdef USECUBEFILTER\n"
1703 "       color.rgb *= myhalf3(textureCube(Texture_Cube, CubeVector));\n"
1704 "# endif\n"
1705 "#endif // MODE_LIGHTSOURCE\n"
1706 "\n"
1707 "\n"
1708 "\n"
1709 "\n"
1710 "#ifdef MODE_LIGHTDIRECTION\n"
1711 "#define SHADING\n"
1712 "#ifdef USEDIFFUSE\n"
1713 "       myhalf3 lightnormal = myhalf3(normalize(LightVector));\n"
1714 "#endif\n"
1715 "#define lightcolor LightColor\n"
1716 "#endif // MODE_LIGHTDIRECTION\n"
1717 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
1718 "#define SHADING\n"
1719 "       // deluxemap lightmapping using light vectors in modelspace (q3map2 -light -deluxe)\n"
1720 "       myhalf3 lightnormal_modelspace = myhalf3(texture2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + myhalf3(-1.0, -1.0, -1.0);\n"
1721 "       myhalf3 lightcolor = myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap));\n"
1722 "       // convert modelspace light vector to tangentspace\n"
1723 "       myhalf3 lightnormal;\n"
1724 "       lightnormal.x = dot(lightnormal_modelspace, myhalf3(VectorS));\n"
1725 "       lightnormal.y = dot(lightnormal_modelspace, myhalf3(VectorT));\n"
1726 "       lightnormal.z = dot(lightnormal_modelspace, myhalf3(VectorR));\n"
1727 "       // calculate directional shading (and undoing the existing angle attenuation on the lightmap by the division)\n"
1728 "       // note that q3map2 is too stupid to calculate proper surface normals when q3map_nonplanar\n"
1729 "       // is used (the lightmap and deluxemap coords correspond to virtually random coordinates\n"
1730 "       // on that luxel, and NOT to its center, because recursive triangle subdivision is used\n"
1731 "       // to map the luxels to coordinates on the draw surfaces), which also causes\n"
1732 "       // deluxemaps to be wrong because light contributions from the wrong side of the surface\n"
1733 "       // are added up. To prevent divisions by zero or strong exaggerations, a max()\n"
1734 "       // nudge is done here at expense of some additional fps. This is ONLY needed for\n"
1735 "       // deluxemaps, tangentspace deluxemap avoid this problem by design.\n"
1736 "       lightcolor *= 1.0 / max(0.25, lightnormal.z);\n"
1737 "#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
1738 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
1739 "#define SHADING\n"
1740 "       // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
1741 "       myhalf3 lightnormal = myhalf3(texture2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + myhalf3(-1.0, -1.0, -1.0);\n"
1742 "       myhalf3 lightcolor = myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap));\n"
1743 "#endif\n"
1744 "\n"
1745 "\n"
1746 "\n"
1747 "\n"
1748 "#ifdef MODE_LIGHTMAP\n"
1749 "       color.rgb = diffusetex * (Color_Ambient + myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap)) * Color_Diffuse);\n"
1750 "#endif // MODE_LIGHTMAP\n"
1751 "#ifdef MODE_VERTEXCOLOR\n"
1752 "       color.rgb = diffusetex * (Color_Ambient + myhalf3(gl_Color.rgb) * Color_Diffuse);\n"
1753 "#endif // MODE_VERTEXCOLOR\n"
1754 "#ifdef MODE_FLATCOLOR\n"
1755 "       color.rgb = diffusetex * Color_Ambient;\n"
1756 "#endif // MODE_FLATCOLOR\n"
1757 "\n"
1758 "\n"
1759 "\n"
1760 "\n"
1761 "#ifdef SHADING\n"
1762 "# ifdef USEDIFFUSE\n"
1763 "       myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1764 "#  ifdef USESPECULAR\n"
1765 "#   ifdef USEEXACTSPECULARMATH\n"
1766 "       myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n"
1767 "#   else\n"
1768 "       myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(EyeVector)));\n"
1769 "       myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n"
1770 "#   endif\n"
1771 "       color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex.rgb * Color_Specular * specular) * lightcolor;\n"
1772 "#  else\n"
1773 "       color.rgb = diffusetex * (Color_Ambient + Color_Diffuse * diffuse * lightcolor);\n"
1774 "#  endif\n"
1775 "# else\n"
1776 "       color.rgb = diffusetex * Color_Ambient;\n"
1777 "# endif\n"
1778 "#endif\n"
1779 "\n"
1780 "#ifdef USESHADOWMAPORTHO\n"
1781 "       color.rgb *= ShadowMapCompare(ShadowMapTC);\n"
1782 "#endif\n"
1783 "\n"
1784 "#ifdef USEDEFERREDLIGHTMAP\n"
1785 "       vec2 ScreenTexCoord = gl_FragCoord.xy * PixelToScreenTexCoord;\n"
1786 "       color.rgb += diffusetex * myhalf3(texture2D(Texture_ScreenDiffuse, ScreenTexCoord)) * DeferredMod_Diffuse;\n"
1787 "       color.rgb += glosstex.rgb * myhalf3(texture2D(Texture_ScreenSpecular, ScreenTexCoord)) * DeferredMod_Specular;\n"
1788 "#endif\n"
1789 "\n"
1790 "#ifdef USEGLOW\n"
1791 "#ifdef USEVERTEXTEXTUREBLEND\n"
1792 "       color.rgb += mix(myhalf3(texture2D(Texture_SecondaryGlow, TexCoord2)), myhalf3(texture2D(Texture_Glow, TexCoord)), terrainblend) * Color_Glow;\n"
1793 "#else\n"
1794 "       color.rgb += myhalf3(texture2D(Texture_Glow, TexCoord)) * Color_Glow;\n"
1795 "#endif\n"
1796 "#endif\n"
1797 "\n"
1798 "#ifdef USEFOG\n"
1799 "       color.rgb = FogVertex(color.rgb);\n"
1800 "#endif\n"
1801 "\n"
1802 "       // 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"
1803 "#ifdef USEREFLECTION\n"
1804 "       vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
1805 "       //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
1806 "       vec2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW.zw + ScreenCenterRefractReflect.zw;\n"
1807 "       vec2 ScreenTexCoord = SafeScreenTexCoord + vec3(normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5))).xy * DistortScaleRefractReflect.zw;\n"
1808 "       // FIXME temporary hack to detect the case that the reflection\n"
1809 "       // gets blackened at edges due to leaving the area that contains actual\n"
1810 "       // content.\n"
1811 "       // Remove this 'ack once we have a better way to stop this thing from\n"
1812 "       // 'appening.\n"
1813 "       float f = min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(0.01, 0.01)).rgb) / 0.05);\n"
1814 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(0.01, -0.01)).rgb) / 0.05);\n"
1815 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
1816 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
1817 "       ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n"
1818 "       color.rgb = mix(color.rgb, myhalf3(texture2D(Texture_Reflection, ScreenTexCoord)) * ReflectColor.rgb, ReflectColor.a);\n"
1819 "#endif\n"
1820 "\n"
1821 "       gl_FragColor = vec4(color);\n"
1822 "}\n"
1823 "#endif // FRAGMENT_SHADER\n"
1824 "\n"
1825 "#endif // !MODE_DEFERREDLIGHTSOURCE\n"
1826 "#endif // !MODE_DEFERREDGEOMETRY\n"
1827 "#endif // !MODE_WATER\n"
1828 "#endif // !MODE_REFRACTION\n"
1829 "#endif // !MODE_BLOOMBLUR\n"
1830 "#endif // !MODE_GENERIC\n"
1831 "#endif // !MODE_POSTPROCESS\n"
1832 "#endif // !MODE_SHOWDEPTH\n"
1833 "#endif // !MODE_DEPTH_OR_SHADOW\n"
1834 ;
1835
1836 /*
1837 =========================================================================================================================================================
1838
1839
1840
1841 =========================================================================================================================================================
1842
1843
1844
1845 =========================================================================================================================================================
1846
1847
1848
1849 =========================================================================================================================================================
1850
1851
1852
1853 =========================================================================================================================================================
1854
1855
1856
1857 =========================================================================================================================================================
1858
1859
1860
1861 =========================================================================================================================================================
1862 */
1863
1864 const char *builtincgshaderstring =
1865 "// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
1866 "// written by Forest 'LordHavoc' Hale\n"
1867 "// shadowmapping enhancements by Lee 'eihrul' Salzman\n"
1868 "\n"
1869 "// FIXME: we need to get rid of ModelViewProjectionPosition to make room for the texcoord for this\n"
1870 "#if defined(USEREFLECTION)\n"
1871 "#undef USESHADOWMAPORTHO\n"
1872 "#endif\n"
1873 "\n"
1874 "#if defined(USEFOGINSIDE) || defined(USEFOGOUTSIDE) || defined(USEFOGHEIGHTTEXTURE)\n"
1875 "# define USEFOG\n"
1876 "#endif\n"
1877 "#if defined(MODE_LIGHTMAP) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
1878 "#define USELIGHTMAP\n"
1879 "#endif\n"
1880 "#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE)\n"
1881 "#define USEEYEVECTOR\n"
1882 "#endif\n"
1883 "\n"
1884 "#ifdef FRAGMENT_SHADER\n"
1885 "#define texDepth2D(tex,texcoord) tex2D(tex,texcoord).r\n"
1886 "#endif\n"
1887 "\n"
1888 "#ifdef MODE_DEPTH_OR_SHADOW\n"
1889 "#ifdef VERTEX_SHADER\n"
1890 "void main\n"
1891 "(\n"
1892 "float4 gl_Vertex : POSITION,\n"
1893 "uniform float4x4 ModelViewProjectionMatrix,\n"
1894 "out float4 gl_Position : POSITION\n"
1895 ")\n"
1896 "{\n"
1897 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
1898 "}\n"
1899 "#endif\n"
1900 "#else // !MODE_DEPTH_ORSHADOW\n"
1901 "\n"
1902 "\n"
1903 "\n"
1904 "\n"
1905 "#ifdef MODE_SHOWDEPTH\n"
1906 "#ifdef VERTEX_SHADER\n"
1907 "void main\n"
1908 "(\n"
1909 "float4 gl_Vertex : POSITION,\n"
1910 "uniform float4x4 ModelViewProjectionMatrix,\n"
1911 "out float4 gl_Position : POSITION,\n"
1912 "out float4 gl_FrontColor : COLOR0\n"
1913 ")\n"
1914 "{\n"
1915 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
1916 "       gl_FrontColor = float4(gl_Position.z, gl_Position.z, gl_Position.z, 1.0);\n"
1917 "}\n"
1918 "#endif\n"
1919 "\n"
1920 "#ifdef FRAGMENT_SHADER\n"
1921 "void main\n"
1922 "(\n"
1923 "float4 gl_FrontColor : COLOR0,\n"
1924 "out float4 gl_FragColor : COLOR\n"
1925 ")\n"
1926 "{\n"
1927 "       gl_FragColor = gl_FrontColor;\n"
1928 "}\n"
1929 "#endif\n"
1930 "#else // !MODE_SHOWDEPTH\n"
1931 "\n"
1932 "\n"
1933 "\n"
1934 "\n"
1935 "#ifdef MODE_POSTPROCESS\n"
1936 "\n"
1937 "#ifdef VERTEX_SHADER\n"
1938 "void main\n"
1939 "(\n"
1940 "float4 gl_Vertex : POSITION,\n"
1941 "uniform float4x4 ModelViewProjectionMatrix,\n"
1942 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
1943 "float4 gl_MultiTexCoord1 : TEXCOORD1,\n"
1944 "out float4 gl_Position : POSITION,\n"
1945 "out float2 TexCoord1 : TEXCOORD0,\n"
1946 "out float2 TexCoord2 : TEXCOORD1\n"
1947 ")\n"
1948 "{\n"
1949 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
1950 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
1951 "#ifdef USEBLOOM\n"
1952 "       TexCoord2 = gl_MultiTexCoord1.xy;\n"
1953 "#endif\n"
1954 "}\n"
1955 "#endif\n"
1956 "\n"
1957 "#ifdef FRAGMENT_SHADER\n"
1958 "void main\n"
1959 "(\n"
1960 "float2 TexCoord1 : TEXCOORD0,\n"
1961 "float2 TexCoord2 : TEXCOORD1,\n"
1962 "uniform sampler2D Texture_First,\n"
1963 "#ifdef USEBLOOM\n"
1964 "uniform sampler2D Texture_Second,\n"
1965 "#endif\n"
1966 "#ifdef USEGAMMARAMPS\n"
1967 "uniform sampler2D Texture_GammaRamps,\n"
1968 "#endif\n"
1969 "#ifdef USESATURATION\n"
1970 "uniform float Saturation,\n"
1971 "#endif\n"
1972 "#ifdef USEVIEWTINT\n"
1973 "uniform float4 ViewTintColor,\n"
1974 "#endif\n"
1975 "uniform float4 UserVec1,\n"
1976 "uniform float4 UserVec2,\n"
1977 "uniform float4 UserVec3,\n"
1978 "uniform float4 UserVec4,\n"
1979 "uniform float ClientTime,\n"
1980 "uniform float2 PixelSize,\n"
1981 "out float4 gl_FragColor : COLOR\n"
1982 ")\n"
1983 "{\n"
1984 "       gl_FragColor = tex2D(Texture_First, TexCoord1);\n"
1985 "#ifdef USEBLOOM\n"
1986 "       gl_FragColor += tex2D(Texture_Second, TexCoord2);\n"
1987 "#endif\n"
1988 "#ifdef USEVIEWTINT\n"
1989 "       gl_FragColor = lerp(gl_FragColor, ViewTintColor, ViewTintColor.a);\n"
1990 "#endif\n"
1991 "\n"
1992 "#ifdef USEPOSTPROCESSING\n"
1993 "// do r_glsl_dumpshader, edit glsl/default.glsl, and replace this by your own postprocessing if you want\n"
1994 "// 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"
1995 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2(-0.987688, -0.156434)) * UserVec1.y;\n"
1996 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2(-0.156434, -0.891007)) * UserVec1.y;\n"
1997 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2( 0.891007, -0.453990)) * UserVec1.y;\n"
1998 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2( 0.707107,  0.707107)) * UserVec1.y;\n"
1999 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2(-0.453990,  0.891007)) * UserVec1.y;\n"
2000 "       gl_FragColor /= (1 + 5 * UserVec1.y);\n"
2001 "#endif\n"
2002 "\n"
2003 "#ifdef USESATURATION\n"
2004 "       //apply saturation BEFORE gamma ramps, so v_glslgamma value does not matter\n"
2005 "       float y = dot(gl_FragColor.rgb, float3(0.299, 0.587, 0.114));\n"
2006 "       //gl_FragColor = float3(y) + (gl_FragColor.rgb - float3(y)) * Saturation;\n"
2007 "       gl_FragColor.rgb = lerp(float3(y), gl_FragColor.rgb, Saturation);\n"
2008 "#endif\n"
2009 "\n"
2010 "#ifdef USEGAMMARAMPS\n"
2011 "       gl_FragColor.r = tex2D(Texture_GammaRamps, float2(gl_FragColor.r, 0)).r;\n"
2012 "       gl_FragColor.g = tex2D(Texture_GammaRamps, float2(gl_FragColor.g, 0)).g;\n"
2013 "       gl_FragColor.b = tex2D(Texture_GammaRamps, float2(gl_FragColor.b, 0)).b;\n"
2014 "#endif\n"
2015 "}\n"
2016 "#endif\n"
2017 "#else // !MODE_POSTPROCESS\n"
2018 "\n"
2019 "\n"
2020 "\n"
2021 "\n"
2022 "#ifdef MODE_GENERIC\n"
2023 "#ifdef VERTEX_SHADER\n"
2024 "void main\n"
2025 "(\n"
2026 "float4 gl_Vertex : POSITION,\n"
2027 "uniform float4x4 ModelViewProjectionMatrix,\n"
2028 "float4 gl_Color : COLOR0,\n"
2029 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2030 "float4 gl_MultiTexCoord1 : TEXCOORD1,\n"
2031 "out float4 gl_Position : POSITION,\n"
2032 "out float4 gl_FrontColor : COLOR,\n"
2033 "out float2 TexCoord1 : TEXCOORD0,\n"
2034 "out float2 TexCoord2 : TEXCOORD1\n"
2035 ")\n"
2036 "{\n"
2037 "       gl_FrontColor = gl_Color;\n"
2038 "#ifdef USEDIFFUSE\n"
2039 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
2040 "#endif\n"
2041 "#ifdef USESPECULAR\n"
2042 "       TexCoord2 = gl_MultiTexCoord1.xy;\n"
2043 "#endif\n"
2044 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2045 "}\n"
2046 "#endif\n"
2047 "\n"
2048 "#ifdef FRAGMENT_SHADER\n"
2049 "\n"
2050 "void main\n"
2051 "(\n"
2052 "float4 gl_FrontColor : COLOR,\n"
2053 "float2 TexCoord1 : TEXCOORD0,\n"
2054 "float2 TexCoord2 : TEXCOORD1,\n"
2055 "#ifdef USEDIFFUSE\n"
2056 "uniform sampler2D Texture_First,\n"
2057 "#endif\n"
2058 "#ifdef USESPECULAR\n"
2059 "uniform sampler2D Texture_Second,\n"
2060 "#endif\n"
2061 "out float4 gl_FragColor : COLOR\n"
2062 ")\n"
2063 "{\n"
2064 "       gl_FragColor = gl_FrontColor;\n"
2065 "#ifdef USEDIFFUSE\n"
2066 "       gl_FragColor *= tex2D(Texture_First, TexCoord1);\n"
2067 "#endif\n"
2068 "\n"
2069 "#ifdef USESPECULAR\n"
2070 "       float4 tex2 = tex2D(Texture_Second, TexCoord2);\n"
2071 "# ifdef USECOLORMAPPING\n"
2072 "       gl_FragColor *= tex2;\n"
2073 "# endif\n"
2074 "# ifdef USEGLOW\n"
2075 "       gl_FragColor += tex2;\n"
2076 "# endif\n"
2077 "# ifdef USEVERTEXTEXTUREBLEND\n"
2078 "       gl_FragColor = lerp(gl_FragColor, tex2, tex2.a);\n"
2079 "# endif\n"
2080 "#endif\n"
2081 "}\n"
2082 "#endif\n"
2083 "#else // !MODE_GENERIC\n"
2084 "\n"
2085 "\n"
2086 "\n"
2087 "\n"
2088 "#ifdef MODE_BLOOMBLUR\n"
2089 "#ifdef VERTEX_SHADER\n"
2090 "void main\n"
2091 "(\n"
2092 "float4 gl_Vertex : POSITION,\n"
2093 "uniform float4x4 ModelViewProjectionMatrix,\n"
2094 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2095 "out float4 gl_Position : POSITION,\n"
2096 "out float2 TexCoord : TEXCOORD0\n"
2097 ")\n"
2098 "{\n"
2099 "       TexCoord = gl_MultiTexCoord0.xy;\n"
2100 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2101 "}\n"
2102 "#endif\n"
2103 "\n"
2104 "#ifdef FRAGMENT_SHADER\n"
2105 "\n"
2106 "void main\n"
2107 "(\n"
2108 "float2 TexCoord : TEXCOORD0,\n"
2109 "uniform sampler2D Texture_First,\n"
2110 "uniform float4 BloomBlur_Parameters,\n"
2111 "out float4 gl_FragColor : COLOR\n"
2112 ")\n"
2113 "{\n"
2114 "       int i;\n"
2115 "       float2 tc = TexCoord;\n"
2116 "       float3 color = tex2D(Texture_First, tc).rgb;\n"
2117 "       tc += BloomBlur_Parameters.xy;\n"
2118 "       for (i = 1;i < SAMPLES;i++)\n"
2119 "       {\n"
2120 "               color += tex2D(Texture_First, tc).rgb;\n"
2121 "               tc += BloomBlur_Parameters.xy;\n"
2122 "       }\n"
2123 "       gl_FragColor = float4(color * BloomBlur_Parameters.z + float3(BloomBlur_Parameters.w), 1);\n"
2124 "}\n"
2125 "#endif\n"
2126 "#else // !MODE_BLOOMBLUR\n"
2127 "#ifdef MODE_REFRACTION\n"
2128 "#ifdef VERTEX_SHADER\n"
2129 "void main\n"
2130 "(\n"
2131 "float4 gl_Vertex : POSITION,\n"
2132 "uniform float4x4 ModelViewProjectionMatrix,\n"
2133 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2134 "uniform float4x4 TexMatrix,\n"
2135 "uniform float3 EyePosition,\n"
2136 "out float4 gl_Position : POSITION,\n"
2137 "out float2 TexCoord : TEXCOORD0,\n"
2138 "out float3 EyeVector : TEXCOORD1,\n"
2139 "out float4 ModelViewProjectionPosition : TEXCOORD2\n"
2140 ")\n"
2141 "{\n"
2142 "       TexCoord = float2(mul(TexMatrix, gl_MultiTexCoord0));\n"
2143 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2144 "       ModelViewProjectionPosition = gl_Position;\n"
2145 "}\n"
2146 "#endif\n"
2147 "\n"
2148 "#ifdef FRAGMENT_SHADER\n"
2149 "void main\n"
2150 "(\n"
2151 "float2 TexCoord : TEXCOORD0,\n"
2152 "float3 EyeVector : TEXCOORD1,\n"
2153 "float4 ModelViewProjectionPosition : TEXCOORD2,\n"
2154 "uniform sampler2D Texture_Normal,\n"
2155 "uniform sampler2D Texture_Refraction,\n"
2156 "uniform sampler2D Texture_Reflection,\n"
2157 "uniform float4 DistortScaleRefractReflect,\n"
2158 "uniform float4 ScreenScaleRefractReflect,\n"
2159 "uniform float4 ScreenCenterRefractReflect,\n"
2160 "uniform float4 RefractColor,\n"
2161 "out float4 gl_FragColor : COLOR\n"
2162 ")\n"
2163 "{\n"
2164 "       float2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
2165 "       //float2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(float3(tex2D(Texture_Normal, TexCoord)) - float3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
2166 "       float2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
2167 "       float2 ScreenTexCoord = SafeScreenTexCoord + float2(normalize(float3(tex2D(Texture_Normal, TexCoord)) - float3(0.5))).xy * DistortScaleRefractReflect.xy;\n"
2168 "       // FIXME temporary hack to detect the case that the reflection\n"
2169 "       // gets blackened at edges due to leaving the area that contains actual\n"
2170 "       // content.\n"
2171 "       // Remove this 'ack once we have a better way to stop this thing from\n"
2172 "       // 'appening.\n"
2173 "       float f = min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(0.01, 0.01)).rgb) / 0.05);\n"
2174 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(0.01, -0.01)).rgb) / 0.05);\n"
2175 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(-0.01, 0.01)).rgb) / 0.05);\n"
2176 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(-0.01, -0.01)).rgb) / 0.05);\n"
2177 "       ScreenTexCoord = lerp(SafeScreenTexCoord, ScreenTexCoord, f);\n"
2178 "       gl_FragColor = tex2D(Texture_Refraction, ScreenTexCoord) * RefractColor;\n"
2179 "}\n"
2180 "#endif\n"
2181 "#else // !MODE_REFRACTION\n"
2182 "\n"
2183 "\n"
2184 "\n"
2185 "\n"
2186 "#ifdef MODE_WATER\n"
2187 "#ifdef VERTEX_SHADER\n"
2188 "\n"
2189 "void main\n"
2190 "(\n"
2191 "float4 gl_Vertex : POSITION,\n"
2192 "uniform float4x4 ModelViewProjectionMatrix,\n"
2193 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2194 "uniform float4x4 TexMatrix,\n"
2195 "uniform float3 EyePosition,\n"
2196 "out float4 gl_Position : POSITION,\n"
2197 "out float2 TexCoord : TEXCOORD0,\n"
2198 "out float3 EyeVector : TEXCOORD1,\n"
2199 "out float4 ModelViewProjectionPosition : TEXCOORD2\n"
2200 ")\n"
2201 "{\n"
2202 "       TexCoord = float2(mul(TexMatrix, gl_MultiTexCoord0));\n"
2203 "       float3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
2204 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
2205 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
2206 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
2207 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2208 "       ModelViewProjectionPosition = gl_Position;\n"
2209 "}\n"
2210 "#endif\n"
2211 "\n"
2212 "#ifdef FRAGMENT_SHADER\n"
2213 "void main\n"
2214 "(\n"
2215 "float2 TexCoord : TEXCOORD0,\n"
2216 "float3 EyeVector : TEXCOORD1,\n"
2217 "float4 ModelViewProjectionPosition : TEXCOORD2,\n"
2218 "uniform sampler2D Texture_Normal,\n"
2219 "uniform sampler2D Texture_Refraction,\n"
2220 "uniform sampler2D Texture_Reflection,\n"
2221 "uniform float4 DistortScaleRefractReflect,\n"
2222 "uniform float4 ScreenScaleRefractReflect,\n"
2223 "uniform float4 ScreenCenterRefractReflect,\n"
2224 "uniform float4 RefractColor,\n"
2225 "uniform float4 ReflectColor,\n"
2226 "uniform float ReflectFactor,\n"
2227 "uniform float ReflectOffset,\n"
2228 "out float4 gl_FragColor : COLOR\n"
2229 ")\n"
2230 "{\n"
2231 "       float4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
2232 "       //float4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(float3(tex2D(Texture_Normal, TexCoord)) - float3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
2233 "       float4 SafeScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
2234 "       float4 ScreenTexCoord = SafeScreenTexCoord + float2(normalize(float3(tex2D(Texture_Normal, TexCoord)) - float3(0.5))).xyxy * DistortScaleRefractReflect;\n"
2235 "       // FIXME temporary hack to detect the case that the reflection\n"
2236 "       // gets blackened at edges due to leaving the area that contains actual\n"
2237 "       // content.\n"
2238 "       // Remove this 'ack once we have a better way to stop this thing from\n"
2239 "       // 'appening.\n"
2240 "       float f = min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(0.01, 0.01)).rgb) / 0.05);\n"
2241 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(0.01, -0.01)).rgb) / 0.05);\n"
2242 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(-0.01, 0.01)).rgb) / 0.05);\n"
2243 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(-0.01, -0.01)).rgb) / 0.05);\n"
2244 "       ScreenTexCoord.xy = lerp(SafeScreenTexCoord.xy, ScreenTexCoord.xy, f);\n"
2245 "       f       = min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(0.01, 0.01)).rgb) / 0.05);\n"
2246 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(0.01, -0.01)).rgb) / 0.05);\n"
2247 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(-0.01, 0.01)).rgb) / 0.05);\n"
2248 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(-0.01, -0.01)).rgb) / 0.05);\n"
2249 "       ScreenTexCoord.zw = lerp(SafeScreenTexCoord.zw, ScreenTexCoord.zw, f);\n"
2250 "       float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 2.0) * ReflectFactor + ReflectOffset;\n"
2251 "       gl_FragColor = lerp(tex2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, tex2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n"
2252 "}\n"
2253 "#endif\n"
2254 "#else // !MODE_WATER\n"
2255 "\n"
2256 "\n"
2257 "\n"
2258 "\n"
2259 "// 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"
2260 "\n"
2261 "// fragment shader specific:\n"
2262 "#ifdef FRAGMENT_SHADER\n"
2263 "\n"
2264 "#ifdef USEFOG\n"
2265 "float3 FogVertex(float3 surfacecolor, float3 FogColor, float3 EyeVectorModelSpace, float FogPlaneVertexDist, float FogRangeRecip, float FogPlaneViewDist, float FogHeightFade, sampler2D Texture_FogMask, sampler2D Texture_FogHeightTexture)\n"
2266 "{\n"
2267 "       float fogfrac;\n"
2268 "#ifdef USEFOGHEIGHTTEXTURE\n"
2269 "       float4 fogheightpixel = tex2D(Texture_FogHeightTexture, float2(1,1) + float2(FogPlaneVertexDist, FogPlaneViewDist) * (-2.0 * FogHeightFade));\n"
2270 "       fogfrac = fogheightpixel.a;\n"
2271 "       return lerp(fogheightpixel.rgb * FogColor, surfacecolor, tex2D(Texture_FogMask, float2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
2272 "#else\n"
2273 "# ifdef USEFOGOUTSIDE\n"
2274 "       fogfrac = min(0.0, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0, min(0.0, FogPlaneVertexDist) * FogHeightFade);\n"
2275 "# else\n"
2276 "       fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0, FogPlaneVertexDist)) * min(1.0, (min(0.0, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);\n"
2277 "# endif\n"
2278 "       return lerp(FogColor, surfacecolor, tex2D(Texture_FogMask, float2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
2279 "#endif\n"
2280 "}\n"
2281 "#endif\n"
2282 "\n"
2283 "#ifdef USEOFFSETMAPPING\n"
2284 "float2 OffsetMapping(float2 TexCoord, float OffsetMapping_Scale, float3 EyeVector, sampler2D Texture_Normal)\n"
2285 "{\n"
2286 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
2287 "       // 14 sample relief mapping: linear search and then binary search\n"
2288 "       // this basically steps forward a small amount repeatedly until it finds\n"
2289 "       // itself inside solid, then jitters forward and back using decreasing\n"
2290 "       // amounts to find the impact\n"
2291 "       //float3 OffsetVector = float3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * float2(-1, 1), -1);\n"
2292 "       //float3 OffsetVector = float3(normalize(EyeVector.xy) * OffsetMapping_Scale * float2(-1, 1), -1);\n"
2293 "       float3 OffsetVector = float3(normalize(EyeVector).xy * OffsetMapping_Scale * float2(-1, 1), -1);\n"
2294 "       float3 RT = float3(TexCoord, 1);\n"
2295 "       OffsetVector *= 0.1;\n"
2296 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2297 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2298 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2299 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2300 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2301 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2302 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2303 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2304 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2305 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z)          - 0.5);\n"
2306 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z) * 0.5    - 0.25);\n"
2307 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z) * 0.25   - 0.125);\n"
2308 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z) * 0.125  - 0.0625);\n"
2309 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
2310 "       return RT.xy;\n"
2311 "#else\n"
2312 "       // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
2313 "       // this basically moves forward the full distance, and then backs up based\n"
2314 "       // on height of samples\n"
2315 "       //float2 OffsetVector = float2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * float2(-1, 1));\n"
2316 "       //float2 OffsetVector = float2(normalize(EyeVector.xy) * OffsetMapping_Scale * float2(-1, 1));\n"
2317 "       float2 OffsetVector = float2(normalize(EyeVector).xy * OffsetMapping_Scale * float2(-1, 1));\n"
2318 "       TexCoord += OffsetVector;\n"
2319 "       OffsetVector *= 0.333;\n"
2320 "       TexCoord -= OffsetVector * tex2D(Texture_Normal, TexCoord).a;\n"
2321 "       TexCoord -= OffsetVector * tex2D(Texture_Normal, TexCoord).a;\n"
2322 "       TexCoord -= OffsetVector * tex2D(Texture_Normal, TexCoord).a;\n"
2323 "       return TexCoord;\n"
2324 "#endif\n"
2325 "}\n"
2326 "#endif // USEOFFSETMAPPING\n"
2327 "\n"
2328 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n"
2329 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n"
2330 "# ifdef USESHADOWMAPORTHO\n"
2331 "#  define GetShadowMapTC2D(dir, ShadowMap_Parameters) (min(dir, ShadowMap_Parameters.xyz))\n"
2332 "# else\n"
2333 "#  ifdef USESHADOWMAPVSDCT\n"
2334 "float3 GetShadowMapTC2D(float3 dir, float4 ShadowMap_Parameters, samplerCUBE Texture_CubeProjection)\n"
2335 "{\n"
2336 "       float3 adir = abs(dir);\n"
2337 "       float2 aparams = ShadowMap_Parameters.xy / max(max(adir.x, adir.y), adir.z);\n"
2338 "       float4 proj = texCUBE(Texture_CubeProjection, dir);\n"
2339 "       return float3(lerp(dir.xy, dir.zz, proj.xy) * aparams.x + proj.zw * ShadowMap_Parameters.z, aparams.y + ShadowMap_Parameters.w);\n"
2340 "}\n"
2341 "#  else\n"
2342 "float3 GetShadowMapTC2D(float3 dir, float4 ShadowMap_Parameters)\n"
2343 "{\n"
2344 "       float3 adir = abs(dir);\n"
2345 "       float ma = adir.z;\n"
2346 "       float4 proj = float4(dir, 2.5);\n"
2347 "       if (adir.x > ma) { ma = adir.x; proj = float4(dir.zyx, 0.5); }\n"
2348 "       if (adir.y > ma) { ma = adir.y; proj = float4(dir.xzy, 1.5); }\n"
2349 "       float2 aparams = ShadowMap_Parameters.xy / ma;\n"
2350 "       return float3(proj.xy * aparams.x + float2(proj.z < 0.0 ? 1.5 : 0.5, proj.w) * ShadowMap_Parameters.z, aparams.y + ShadowMap_Parameters.w);\n"
2351 "}\n"
2352 "#  endif\n"
2353 "# endif\n"
2354 "#endif // defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n"
2355 "\n"
2356 "#ifdef USESHADOWMAPCUBE\n"
2357 "float4 GetShadowMapTCCube(float3 dir, float4 ShadowMap_Parameters)\n"
2358 "{\n"
2359 "    float3 adir = abs(dir);\n"
2360 "    return float4(dir, ShadowMap_Parameters.w + ShadowMap_Parameters.y / max(max(adir.x, adir.y), adir.z));\n"
2361 "}\n"
2362 "#endif\n"
2363 "\n"
2364 "# ifdef USESHADOWMAPRECT\n"
2365 "#ifdef USESHADOWMAPVSDCT\n"
2366 "float ShadowMapCompare(float3 dir, samplerRECT Texture_ShadowMapRect, float4 ShadowMap_Parameters, samplerCUBE Texture_CubeProjection)\n"
2367 "#else\n"
2368 "float ShadowMapCompare(float3 dir, samplerRECT Texture_ShadowMapRect, float4 ShadowMap_Parameters)\n"
2369 "#endif\n"
2370 "{\n"
2371 "#ifdef USESHADOWMAPVSDCT\n"
2372 "       float3 shadowmaptc = GetShadowMapTC2D(dir, ShadowMap_Parameters, Texture_CubeProjection);\n"
2373 "#else\n"
2374 "       float3 shadowmaptc = GetShadowMapTC2D(dir, ShadowMap_Parameters);\n"
2375 "#endif\n"
2376 "       float f;\n"
2377 "#  ifdef USESHADOWSAMPLER\n"
2378 "\n"
2379 "#    ifdef USESHADOWMAPPCF\n"
2380 "#      define texval(x, y) shadow2DRect(Texture_ShadowMapRect, shadowmaptc + float3(x, y, 0.0)).r\n"
2381 "    f = dot(float4(0.25), float4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n"
2382 "#    else\n"
2383 "    f = shadow2DRect(Texture_ShadowMapRect, shadowmaptc).r;\n"
2384 "#    endif\n"
2385 "\n"
2386 "#  else\n"
2387 "\n"
2388 "#    ifdef USESHADOWMAPPCF\n"
2389 "#      if USESHADOWMAPPCF > 1\n"
2390 "#        define texval(x, y) texRECT(Texture_ShadowMapRect, center + float2(x, y)).r\n"
2391 "    float2 center = shadowmaptc.xy - 0.5, offset = frac(center);\n"
2392 "    float4 row1 = step(shadowmaptc.z, float4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n"
2393 "    float4 row2 = step(shadowmaptc.z, float4(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0), texval( 2.0,  0.0)));\n"
2394 "    float4 row3 = step(shadowmaptc.z, float4(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0), texval( 2.0,  1.0)));\n"
2395 "    float4 row4 = step(shadowmaptc.z, float4(texval(-1.0,  2.0), texval( 0.0,  2.0), texval( 1.0,  2.0), texval( 2.0,  2.0)));\n"
2396 "    float4 cols = row2 + row3 + lerp(row1, row4, offset.y);\n"
2397 "    f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n"
2398 "#      else\n"
2399 "#        define texval(x, y) texRECT(Texture_ShadowMapRect, shadowmaptc.xy + float2(x, y)).r\n"
2400 "    float2 offset = frac(shadowmaptc.xy);\n"
2401 "    float3 row1 = step(shadowmaptc.z, float3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
2402 "    float3 row2 = step(shadowmaptc.z, float3(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0)));\n"
2403 "    float3 row3 = step(shadowmaptc.z, float3(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0)));\n"
2404 "    float3 cols = row2 + lerp(row1, row3, offset.y);\n"
2405 "    f = dot(lerp(cols.xy, cols.yz, offset.x), float2(0.25));\n"
2406 "#      endif\n"
2407 "#    else\n"
2408 "    f = step(shadowmaptc.z, texRECT(Texture_ShadowMapRect, shadowmaptc.xy).r);\n"
2409 "#    endif\n"
2410 "\n"
2411 "#  endif\n"
2412 "#  ifdef USESHADOWMAPORTHO\n"
2413 "       return lerp(ShadowMap_Parameters.w, 1.0, f);\n"
2414 "#  else\n"
2415 "       return f;\n"
2416 "#  endif\n"
2417 "}\n"
2418 "# endif\n"
2419 "\n"
2420 "# ifdef USESHADOWMAP2D\n"
2421 "#ifdef USESHADOWMAPVSDCT\n"
2422 "float ShadowMapCompare(float3 dir, sampler2D Texture_ShadowMap2D, float4 ShadowMap_Parameters, float2 ShadowMap_TextureScale, samplerCUBE Texture_CubeProjection)\n"
2423 "#else\n"
2424 "float ShadowMapCompare(float3 dir, sampler2D Texture_ShadowMap2D, float4 ShadowMap_Parameters, float2 ShadowMap_TextureScale)\n"
2425 "#endif\n"
2426 "{\n"
2427 "#ifdef USESHADOWMAPVSDCT\n"
2428 "       float3 shadowmaptc = GetShadowMapTC2D(dir, ShadowMap_Parameters, Texture_CubeProjection);\n"
2429 "#else\n"
2430 "       float3 shadowmaptc = GetShadowMapTC2D(dir, ShadowMap_Parameters);\n"
2431 "#endif\n"
2432 "    float f;\n"
2433 "\n"
2434 "#  ifdef USESHADOWSAMPLER\n"
2435 "#    ifdef USESHADOWMAPPCF\n"
2436 "#      define texval(x, y) shadow2D(Texture_ShadowMap2D, float3(center + float2(x, y)*ShadowMap_TextureScale, shadowmaptc.z)).r  \n"
2437 "    float2 center = shadowmaptc.xy*ShadowMap_TextureScale;\n"
2438 "    f = dot(float4(0.25), float4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n"
2439 "#    else\n"
2440 "    f = shadow2D(Texture_ShadowMap2D, float3(shadowmaptc.xy*ShadowMap_TextureScale, shadowmaptc.z)).r;\n"
2441 "#    endif\n"
2442 "#  else\n"
2443 "#    ifdef USESHADOWMAPPCF\n"
2444 "#     if defined(GL_ARB_texture_gather) || defined(GL_AMD_texture_texture4)\n"
2445 "#      ifdef GL_ARB_texture_gather\n"
2446 "#        define texval(x, y) textureGatherOffset(Texture_ShadowMap2D, center, ivec(x, y))\n"
2447 "#      else\n"
2448 "#        define texval(x, y) texture4(Texture_ShadowMap2D, center + float2(x,y)*ShadowMap_TextureScale)\n"
2449 "#      endif\n"
2450 "    float2 center = shadowmaptc.xy - 0.5, offset = frac(center);\n"
2451 "    center *= ShadowMap_TextureScale;\n"
2452 "    float4 group1 = step(shadowmaptc.z, texval(-1.0, -1.0));\n"
2453 "    float4 group2 = step(shadowmaptc.z, texval( 1.0, -1.0));\n"
2454 "    float4 group3 = step(shadowmaptc.z, texval(-1.0,  1.0));\n"
2455 "    float4 group4 = step(shadowmaptc.z, texval( 1.0,  1.0));\n"
2456 "    float4 cols = float4(group1.rg, group2.rg) + float4(group3.ab, group4.ab) +\n"
2457 "                lerp(float4(group1.ab, group2.ab), float4(group3.rg, group4.rg), offset.y);\n"
2458 "    f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n"
2459 "#     else\n"
2460 "#        define texval(x, y) texDepth2D(Texture_ShadowMap2D, center + float2(x, y)*ShadowMap_TextureScale)  \n"
2461 "#      if USESHADOWMAPPCF > 1\n"
2462 "    float2 center = shadowmaptc.xy - 0.5, offset = frac(center);\n"
2463 "    center *= ShadowMap_TextureScale;\n"
2464 "    float4 row1 = step(shadowmaptc.z, float4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n"
2465 "    float4 row2 = step(shadowmaptc.z, float4(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0), texval( 2.0,  0.0)));\n"
2466 "    float4 row3 = step(shadowmaptc.z, float4(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0), texval( 2.0,  1.0)));\n"
2467 "    float4 row4 = step(shadowmaptc.z, float4(texval(-1.0,  2.0), texval( 0.0,  2.0), texval( 1.0,  2.0), texval( 2.0,  2.0)));\n"
2468 "    float4 cols = row2 + row3 + lerp(row1, row4, offset.y);\n"
2469 "    f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n"
2470 "#      else\n"
2471 "    float2 center = shadowmaptc.xy*ShadowMap_TextureScale, offset = frac(shadowmaptc.xy);\n"
2472 "    float3 row1 = step(shadowmaptc.z, float3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
2473 "    float3 row2 = step(shadowmaptc.z, float3(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0)));\n"
2474 "    float3 row3 = step(shadowmaptc.z, float3(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0)));\n"
2475 "    float3 cols = row2 + lerp(row1, row3, offset.y);\n"
2476 "    f = dot(lerp(cols.xy, cols.yz, offset.x), float2(0.25));\n"
2477 "#      endif\n"
2478 "#     endif\n"
2479 "#    else\n"
2480 "    f = step(shadowmaptc.z, tex2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale).r);\n"
2481 "#    endif\n"
2482 "#  endif\n"
2483 "#  ifdef USESHADOWMAPORTHO\n"
2484 "       return lerp(ShadowMap_Parameters.w, 1.0, f);\n"
2485 "#  else\n"
2486 "       return f;\n"
2487 "#  endif\n"
2488 "}\n"
2489 "# endif\n"
2490 "\n"
2491 "# ifdef USESHADOWMAPCUBE\n"
2492 "float ShadowMapCompare(float3 dir, samplerCUBE Texture_ShadowMapCube, float4 ShadowMap_Parameters)\n"
2493 "{\n"
2494 "    // apply depth texture cubemap as light filter\n"
2495 "    float4 shadowmaptc = GetShadowMapTCCube(dir, ShadowMap_Parameters);\n"
2496 "    float f;\n"
2497 "#  ifdef USESHADOWSAMPLER\n"
2498 "    f = shadowCube(Texture_ShadowMapCube, shadowmaptc).r;\n"
2499 "#  else\n"
2500 "    f = step(shadowmaptc.w, texCUBE(Texture_ShadowMapCube, shadowmaptc.xyz).r);\n"
2501 "#  endif\n"
2502 "    return f;\n"
2503 "}\n"
2504 "# endif\n"
2505 "#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE)\n"
2506 "#endif // FRAGMENT_SHADER\n"
2507 "\n"
2508 "\n"
2509 "\n"
2510 "\n"
2511 "#ifdef MODE_DEFERREDGEOMETRY\n"
2512 "#ifdef VERTEX_SHADER\n"
2513 "void main\n"
2514 "(\n"
2515 "float4 gl_Vertex : POSITION,\n"
2516 "uniform float4x4 ModelViewProjectionMatrix,\n"
2517 "#ifdef USEVERTEXTEXTUREBLEND\n"
2518 "float4 gl_Color : COLOR0,\n"
2519 "#endif\n"
2520 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2521 "float4 gl_MultiTexCoord1 : TEXCOORD1,\n"
2522 "float4 gl_MultiTexCoord2 : TEXCOORD2,\n"
2523 "float4 gl_MultiTexCoord3 : TEXCOORD3,\n"
2524 "uniform float4x4 TexMatrix,\n"
2525 "#ifdef USEVERTEXTEXTUREBLEND\n"
2526 "uniform float4x4 BackgroundTexMatrix,\n"
2527 "#endif\n"
2528 "uniform float4x4 ModelViewMatrix,\n"
2529 "#ifdef USEOFFSETMAPPING\n"
2530 "uniform float3 EyePosition,\n"
2531 "#endif\n"
2532 "out float4 gl_Position : POSITION,\n"
2533 "out float4 gl_FrontColor : COLOR,\n"
2534 "out float4 TexCoordBoth : TEXCOORD0,\n"
2535 "#ifdef USEOFFSETMAPPING\n"
2536 "out float3 EyeVector : TEXCOORD2,\n"
2537 "#endif\n"
2538 "out float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n"
2539 "out float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n"
2540 "out float3 VectorR : TEXCOORD7 // direction of R texcoord (surface normal)\n"
2541 ")\n"
2542 "{\n"
2543 "       TexCoordBoth = mul(TexMatrix, gl_MultiTexCoord0);\n"
2544 "#ifdef USEVERTEXTEXTUREBLEND\n"
2545 "       gl_FrontColor = gl_Color;\n"
2546 "       TexCoordBoth.zw = float2(Backgroundmul(TexMatrix, gl_MultiTexCoord0));\n"
2547 "#endif\n"
2548 "\n"
2549 "       // transform unnormalized eye direction into tangent space\n"
2550 "#ifdef USEOFFSETMAPPING\n"
2551 "       float3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
2552 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
2553 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
2554 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
2555 "#endif\n"
2556 "\n"
2557 "       VectorS = mul(ModelViewMatrix, float4(gl_MultiTexCoord1.xyz, 0)).xyz;\n"
2558 "       VectorT = mul(ModelViewMatrix, float4(gl_MultiTexCoord2.xyz, 0)).xyz;\n"
2559 "       VectorR = mul(ModelViewMatrix, float4(gl_MultiTexCoord3.xyz, 0)).xyz;\n"
2560 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2561 "}\n"
2562 "#endif // VERTEX_SHADER\n"
2563 "\n"
2564 "#ifdef FRAGMENT_SHADER\n"
2565 "void main\n"
2566 "(\n"
2567 "float4 TexCoordBoth : TEXCOORD0,\n"
2568 "float3 EyeVector : TEXCOORD2,\n"
2569 "float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n"
2570 "float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n"
2571 "float3 VectorR : TEXCOORD7, // direction of R texcoord (surface normal)\n"
2572 "uniform sampler2D Texture_Normal,\n"
2573 "#ifdef USEALPHAKILL\n"
2574 "uniform sampler2D Texture_Color,\n"
2575 "#endif\n"
2576 "uniform sampler2D Texture_Gloss,\n"
2577 "#ifdef USEVERTEXTEXTUREBLEND\n"
2578 "uniform sampler2D Texture_SecondaryNormal,\n"
2579 "uniform sampler2D Texture_SecondaryGloss,\n"
2580 "#endif\n"
2581 "#ifdef USEOFFSETMAPPING\n"
2582 "uniform float OffsetMapping_Scale,\n"
2583 "#endif\n"
2584 "uniform half SpecularPower,\n"
2585 "out float4 gl_FragColor : COLOR\n"
2586 ")\n"
2587 "{\n"
2588 "       float2 TexCoord = TexCoordBoth.xy;\n"
2589 "#ifdef USEOFFSETMAPPING\n"
2590 "       // apply offsetmapping\n"
2591 "       float2 TexCoordOffset = OffsetMapping(TexCoord, OffsetMapping_Scale, EyeVector, Texture_Normal);\n"
2592 "#define TexCoord TexCoordOffset\n"
2593 "#endif\n"
2594 "\n"
2595 "#ifdef USEALPHAKILL\n"
2596 "       if (tex2D(Texture_Color, TexCoord).a < 0.5)\n"
2597 "               discard;\n"
2598 "#endif\n"
2599 "\n"
2600 "#ifdef USEVERTEXTEXTUREBLEND\n"
2601 "       float alpha = tex2D(Texture_Color, TexCoord).a;\n"
2602 "       float terrainblend = clamp(float(gl_FrontColor.a) * alpha * 2.0 - 0.5, float(0.0), float(1.0));\n"
2603 "       //float terrainblend = min(float(gl_FrontColor.a) * alpha * 2.0, float(1.0));\n"
2604 "       //float terrainblend = float(gl_FrontColor.a) * alpha > 0.5;\n"
2605 "#endif\n"
2606 "\n"
2607 "#ifdef USEVERTEXTEXTUREBLEND\n"
2608 "       float3 surfacenormal = lerp(float3(tex2D(Texture_SecondaryNormal, TexCoord2)), float3(tex2D(Texture_Normal, TexCoord)), terrainblend) - float3(0.5, 0.5, 0.5);\n"
2609 "       float a = lerp(tex2D(Texture_SecondaryGloss, TexCoord2), tex2D(Texture_Gloss, TexCoord).a, terrainblend);\n"
2610 "#else\n"
2611 "       float3 surfacenormal = float3(tex2D(Texture_Normal, TexCoord)) - float3(0.5, 0.5, 0.5);\n"
2612 "       float a = tex2D(Texture_Gloss, TexCoord).a;\n"
2613 "#endif\n"
2614 "\n"
2615 "       gl_FragColor = float4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR) * 0.5 + float3(0.5, 0.5, 0.5), 1);\n"
2616 "}\n"
2617 "#endif // FRAGMENT_SHADER\n"
2618 "#else // !MODE_DEFERREDGEOMETRY\n"
2619 "\n"
2620 "\n"
2621 "\n"
2622 "\n"
2623 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
2624 "#ifdef VERTEX_SHADER\n"
2625 "void main\n"
2626 "(\n"
2627 "float4 gl_Vertex : POSITION,\n"
2628 "uniform float4x4 ModelViewProjectionMatrix,\n"
2629 "uniform float4x4 ModelViewMatrix,\n"
2630 "out float4 gl_Position : POSITION,\n"
2631 "out float4 ModelViewPosition : TEXCOORD0\n"
2632 ")\n"
2633 "{\n"
2634 "       ModelViewPosition = mul(ModelViewMatrix, gl_Vertex);\n"
2635 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2636 "}\n"
2637 "#endif // VERTEX_SHADER\n"
2638 "\n"
2639 "#ifdef FRAGMENT_SHADER\n"
2640 "void main\n"
2641 "(\n"
2642 "float2 Pixel : WPOS,\n"
2643 "float4 ModelViewPosition : TEXCOORD0,\n"
2644 "uniform float4x4 ViewToLight,\n"
2645 "uniform float2 ScreenToDepth, // ScreenToDepth = float2(Far / (Far - Near), Far * Near / (Near - Far));\n"
2646 "uniform float3 LightPosition,\n"
2647 "uniform half2 PixelToScreenTexCoord,\n"
2648 "uniform half3 DeferredColor_Ambient,\n"
2649 "uniform half3 DeferredColor_Diffuse,\n"
2650 "#ifdef USESPECULAR\n"
2651 "uniform half3 DeferredColor_Specular,\n"
2652 "uniform half SpecularPower,\n"
2653 "#endif\n"
2654 "uniform sampler2D Texture_Attenuation,\n"
2655 "uniform sampler2D Texture_ScreenDepth,\n"
2656 "uniform sampler2D Texture_ScreenNormalMap,\n"
2657 "\n"
2658 "#ifdef USECUBEFILTER\n"
2659 "uniform samplerCUBE Texture_Cube,\n"
2660 "#endif\n"
2661 "\n"
2662 "#ifdef USESHADOWMAPRECT\n"
2663 "# ifdef USESHADOWSAMPLER\n"
2664 "uniform samplerRECTShadow Texture_ShadowMapRect,\n"
2665 "# else\n"
2666 "uniform samplerRECT Texture_ShadowMapRect,\n"
2667 "# endif\n"
2668 "#endif\n"
2669 "\n"
2670 "#ifdef USESHADOWMAP2D\n"
2671 "# ifdef USESHADOWSAMPLER\n"
2672 "uniform sampler2DShadow Texture_ShadowMap2D,\n"
2673 "# else\n"
2674 "uniform sampler2D Texture_ShadowMap2D,\n"
2675 "# endif\n"
2676 "#endif\n"
2677 "\n"
2678 "#ifdef USESHADOWMAPVSDCT\n"
2679 "uniform samplerCUBE Texture_CubeProjection,\n"
2680 "#endif\n"
2681 "\n"
2682 "#ifdef USESHADOWMAPCUBE\n"
2683 "# ifdef USESHADOWSAMPLER\n"
2684 "uniform samplerCUBEShadow Texture_ShadowMapCube,\n"
2685 "# else\n"
2686 "uniform samplerCUBE Texture_ShadowMapCube,\n"
2687 "# endif\n"
2688 "#endif\n"
2689 "\n"
2690 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D) || defined(USESHADOWMAPCUBE)\n"
2691 "uniform float2 ShadowMap_TextureScale,\n"
2692 "uniform float4 ShadowMap_Parameters,\n"
2693 "#endif\n"
2694 "\n"
2695 "out float4 gl_FragData0 : COLOR0,\n"
2696 "out float4 gl_FragData1 : COLOR1\n"
2697 ")\n"
2698 "{\n"
2699 "       // calculate viewspace pixel position\n"
2700 "       float2 ScreenTexCoord = Pixel * PixelToScreenTexCoord;\n"
2701 "       //ScreenTexCoord.y = ScreenTexCoord.y * -1 + 1; // Cg is opposite?\n"
2702 "       float3 position;\n"
2703 "       position.z = ScreenToDepth.y / (texDepth2D(Texture_ScreenDepth, ScreenTexCoord) + ScreenToDepth.x);\n"
2704 "       position.xy = ModelViewPosition.xy * (position.z / ModelViewPosition.z);\n"
2705 "       // decode viewspace pixel normal\n"
2706 "       half4 normalmap = tex2D(Texture_ScreenNormalMap, ScreenTexCoord);\n"
2707 "       half3 surfacenormal = normalize(normalmap.rgb - half3(0.5,0.5,0.5));\n"
2708 "       // surfacenormal = pixel normal in viewspace\n"
2709 "       // LightVector = pixel to light in viewspace\n"
2710 "       // CubeVector = position in lightspace\n"
2711 "       // eyevector = pixel to view in viewspace\n"
2712 "       float3 CubeVector = float3(mul(ViewToLight, float4(position,1)));\n"
2713 "       half fade = half(tex2D(Texture_Attenuation, float2(length(CubeVector), 0.0)));\n"
2714 "#ifdef USEDIFFUSE\n"
2715 "       // calculate diffuse shading\n"
2716 "       half3 lightnormal = half3(normalize(LightPosition - position));\n"
2717 "       half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
2718 "#endif\n"
2719 "#ifdef USESPECULAR\n"
2720 "       // calculate directional shading\n"
2721 "       float3 eyevector = position * -1.0;\n"
2722 "#  ifdef USEEXACTSPECULARMATH\n"
2723 "       half specular = pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower * normalmap.a);\n"
2724 "#  else\n"
2725 "       half3 specularnormal = normalize(lightnormal + half3(normalize(eyevector)));\n"
2726 "       half specular = pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * normalmap.a);\n"
2727 "#  endif\n"
2728 "#endif\n"
2729 "\n"
2730 "#if defined(USESHADOWMAP2D) || defined(USESHADOWMAPRECT) || defined(USESHADOWMAPCUBE)\n"
2731 "       fade *= ShadowMapCompare(CubeVector,\n"
2732 "# if defined(USESHADOWMAP2D)\n"
2733 "Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n"
2734 "# endif\n"
2735 "# if defined(USESHADOWMAPRECT)\n"
2736 "Texture_ShadowMapRect, ShadowMap_Parameters\n"
2737 "# endif\n"
2738 "# if defined(USESHADOWMAPCUBE)\n"
2739 "Texture_ShadowMapCube, ShadowMap_Parameters\n"
2740 "# endif\n"
2741 "\n"
2742 "#ifdef USESHADOWMAPVSDCT\n"
2743 ", Texture_CubeProjection\n"
2744 "#endif\n"
2745 "       );\n"
2746 "#endif\n"
2747 "\n"
2748 "#ifdef USEDIFFUSE\n"
2749 "       gl_FragData0 = float4((DeferredColor_Ambient + DeferredColor_Diffuse * diffuse) * fade, 1.0);\n"
2750 "#else\n"
2751 "       gl_FragData0 = float4(DeferredColor_Ambient * fade, 1.0);\n"
2752 "#endif\n"
2753 "#ifdef USESPECULAR\n"
2754 "       gl_FragData1 = float4(DeferredColor_Specular * (specular * fade), 1.0);\n"
2755 "#else\n"
2756 "       gl_FragData1 = float4(0.0, 0.0, 0.0, 1.0);\n"
2757 "#endif\n"
2758 "\n"
2759 "# ifdef USECUBEFILTER\n"
2760 "       float3 cubecolor = texCUBE(Texture_Cube, CubeVector).rgb;\n"
2761 "       gl_FragData0.rgb *= cubecolor;\n"
2762 "       gl_FragData1.rgb *= cubecolor;\n"
2763 "# endif\n"
2764 "}\n"
2765 "#endif // FRAGMENT_SHADER\n"
2766 "#else // !MODE_DEFERREDLIGHTSOURCE\n"
2767 "\n"
2768 "\n"
2769 "\n"
2770 "\n"
2771 "#ifdef VERTEX_SHADER\n"
2772 "void main\n"
2773 "(\n"
2774 "float4 gl_Vertex : POSITION,\n"
2775 "uniform float4x4 ModelViewProjectionMatrix,\n"
2776 "#if defined(USEVERTEXTEXTUREBLEND) || defined(MODE_VERTEXCOLOR)\n"
2777 "float4 gl_Color : COLOR0,\n"
2778 "#endif\n"
2779 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2780 "float4 gl_MultiTexCoord1 : TEXCOORD1,\n"
2781 "float4 gl_MultiTexCoord2 : TEXCOORD2,\n"
2782 "float4 gl_MultiTexCoord3 : TEXCOORD3,\n"
2783 "float4 gl_MultiTexCoord4 : TEXCOORD4,\n"
2784 "\n"
2785 "uniform float3 EyePosition,\n"
2786 "uniform float4x4 TexMatrix,\n"
2787 "#ifdef USEVERTEXTEXTUREBLEND\n"
2788 "uniform float4x4 BackgroundTexMatrix,\n"
2789 "#endif\n"
2790 "#ifdef MODE_LIGHTSOURCE\n"
2791 "uniform float4x4 ModelToLight,\n"
2792 "#endif\n"
2793 "#ifdef MODE_LIGHTSOURCE\n"
2794 "uniform float3 LightPosition,\n"
2795 "#endif\n"
2796 "#ifdef MODE_LIGHTDIRECTION\n"
2797 "uniform float3 LightDir,\n"
2798 "#endif\n"
2799 "uniform float4 FogPlane,\n"
2800 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
2801 "uniform float3 LightPosition,\n"
2802 "#endif\n"
2803 "#ifdef USESHADOWMAPORTHO\n"
2804 "uniform float4x4 ShadowMapMatrix,\n"
2805 "#endif\n"
2806 "\n"
2807 "out float4 gl_FrontColor : COLOR,\n"
2808 "out float4 TexCoordBoth : TEXCOORD0,\n"
2809 "#ifdef USELIGHTMAP\n"
2810 "out float2 TexCoordLightmap : TEXCOORD1,\n"
2811 "#endif\n"
2812 "#ifdef USEEYEVECTOR\n"
2813 "out float3 EyeVector : TEXCOORD2,\n"
2814 "#endif\n"
2815 "#ifdef USEREFLECTION\n"
2816 "out float4 ModelViewProjectionPosition : TEXCOORD3,\n"
2817 "#endif\n"
2818 "#ifdef USEFOG\n"
2819 "out float4 EyeVectorModelSpaceFogPlaneVertexDist : TEXCOORD4,\n"
2820 "#endif\n"
2821 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_LIGHTDIRECTION)\n"
2822 "out float3 LightVector : TEXCOORD1,\n"
2823 "#endif\n"
2824 "#ifdef MODE_LIGHTSOURCE\n"
2825 "out float3 CubeVector : TEXCOORD3,\n"
2826 "#endif\n"
2827 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n"
2828 "out float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n"
2829 "out float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n"
2830 "out float3 VectorR : TEXCOORD7, // direction of R texcoord (surface normal)\n"
2831 "#endif\n"
2832 "#ifdef USESHADOWMAPORTHO\n"
2833 "out float3 ShadowMapTC : TEXCOORD3, // CONFLICTS WITH USEREFLECTION!\n"
2834 "#endif\n"
2835 "out float4 gl_Position : POSITION\n"
2836 ")\n"
2837 "{\n"
2838 "#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n"
2839 "       gl_FrontColor = gl_Color;\n"
2840 "#endif\n"
2841 "       // copy the surface texcoord\n"
2842 "       TexCoordBoth = mul(TexMatrix, gl_MultiTexCoord0);\n"
2843 "#ifdef USEVERTEXTEXTUREBLEND\n"
2844 "       TexCoordBoth.zw = mul(BackgroundTexMatrix, gl_MultiTexCoord0).xy;\n"
2845 "#endif\n"
2846 "#ifdef USELIGHTMAP\n"
2847 "       TexCoordLightmap = float2(gl_MultiTexCoord4);\n"
2848 "#endif\n"
2849 "\n"
2850 "#ifdef MODE_LIGHTSOURCE\n"
2851 "       // transform vertex position into light attenuation/cubemap space\n"
2852 "       // (-1 to +1 across the light box)\n"
2853 "       CubeVector = float3(mul(ModelToLight, gl_Vertex));\n"
2854 "\n"
2855 "# ifdef USEDIFFUSE\n"
2856 "       // transform unnormalized light direction into tangent space\n"
2857 "       // (we use unnormalized to ensure that it interpolates correctly and then\n"
2858 "       //  normalize it per pixel)\n"
2859 "       float3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
2860 "       LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
2861 "       LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
2862 "       LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
2863 "# endif\n"
2864 "#endif\n"
2865 "\n"
2866 "#if defined(MODE_LIGHTDIRECTION) && defined(USEDIFFUSE)\n"
2867 "       LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);\n"
2868 "       LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);\n"
2869 "       LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);\n"
2870 "#endif\n"
2871 "\n"
2872 "       // transform unnormalized eye direction into tangent space\n"
2873 "#ifdef USEEYEVECTOR\n"
2874 "       float3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
2875 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
2876 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
2877 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
2878 "#endif\n"
2879 "\n"
2880 "#ifdef USEFOG\n"
2881 "       EyeVectorModelSpaceFogPlaneVertexDist.xyz = EyePosition - gl_Vertex.xyz;\n"
2882 "       EyeVectorModelSpaceFogPlaneVertexDist.w = dot(FogPlane, gl_Vertex);\n"
2883 "#endif\n"
2884 "\n"
2885 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
2886 "       VectorS = gl_MultiTexCoord1.xyz;\n"
2887 "       VectorT = gl_MultiTexCoord2.xyz;\n"
2888 "       VectorR = gl_MultiTexCoord3.xyz;\n"
2889 "#endif\n"
2890 "\n"
2891 "       // transform vertex to camera space, using ftransform to match non-VS rendering\n"
2892 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2893 "\n"
2894 "#ifdef USESHADOWMAPORTHO\n"
2895 "       ShadowMapTC = float3(mul(ShadowMapMatrix, gl_Position));\n"
2896 "#endif\n"
2897 "\n"
2898 "#ifdef USEREFLECTION\n"
2899 "       ModelViewProjectionPosition = gl_Position;\n"
2900 "#endif\n"
2901 "}\n"
2902 "#endif // VERTEX_SHADER\n"
2903 "\n"
2904 "\n"
2905 "\n"
2906 "\n"
2907 "#ifdef FRAGMENT_SHADER\n"
2908 "void main\n"
2909 "(\n"
2910 "#ifdef USEDEFERREDLIGHTMAP\n"
2911 "float2 Pixel : WPOS,\n"
2912 "#endif\n"
2913 "float4 gl_FrontColor : COLOR,\n"
2914 "float4 TexCoordBoth : TEXCOORD0,\n"
2915 "#ifdef USELIGHTMAP\n"
2916 "float2 TexCoordLightmap : TEXCOORD1,\n"
2917 "#endif\n"
2918 "#ifdef USEEYEVECTOR\n"
2919 "float3 EyeVector : TEXCOORD2,\n"
2920 "#endif\n"
2921 "#ifdef USEREFLECTION\n"
2922 "float4 ModelViewProjectionPosition : TEXCOORD3,\n"
2923 "#endif\n"
2924 "#ifdef USEFOG\n"
2925 "float4 EyeVectorModelSpaceFogPlaneVertexDist : TEXCOORD4,\n"
2926 "#endif\n"
2927 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_LIGHTDIRECTION)\n"
2928 "float3 LightVector : TEXCOORD1,\n"
2929 "#endif\n"
2930 "#ifdef MODE_LIGHTSOURCE\n"
2931 "float3 CubeVector : TEXCOORD3,\n"
2932 "#endif\n"
2933 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
2934 "float4 ModelViewPosition : TEXCOORD0,\n"
2935 "#endif\n"
2936 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n"
2937 "float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n"
2938 "float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n"
2939 "float3 VectorR : TEXCOORD7, // direction of R texcoord (surface normal)\n"
2940 "#endif\n"
2941 "#ifdef USESHADOWMAPORTHO\n"
2942 "float3 ShadowMapTC : TEXCOORD3, // CONFLICTS WITH USEREFLECTION!\n"
2943 "#endif\n"
2944 "\n"
2945 "uniform sampler2D Texture_Normal,\n"
2946 "uniform sampler2D Texture_Color,\n"
2947 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
2948 "uniform sampler2D Texture_Gloss,\n"
2949 "#endif\n"
2950 "#ifdef USEGLOW\n"
2951 "uniform sampler2D Texture_Glow,\n"
2952 "#endif\n"
2953 "#ifdef USEVERTEXTEXTUREBLEND\n"
2954 "uniform sampler2D Texture_SecondaryNormal,\n"
2955 "uniform sampler2D Texture_SecondaryColor,\n"
2956 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
2957 "uniform sampler2D Texture_SecondaryGloss,\n"
2958 "#endif\n"
2959 "#ifdef USEGLOW\n"
2960 "uniform sampler2D Texture_SecondaryGlow,\n"
2961 "#endif\n"
2962 "#endif\n"
2963 "#ifdef USECOLORMAPPING\n"
2964 "uniform sampler2D Texture_Pants,\n"
2965 "uniform sampler2D Texture_Shirt,\n"
2966 "#endif\n"
2967 "#ifdef USEFOG\n"
2968 "uniform sampler2D Texture_FogHeightTexture,\n"
2969 "uniform sampler2D Texture_FogMask,\n"
2970 "#endif\n"
2971 "#ifdef USELIGHTMAP\n"
2972 "uniform sampler2D Texture_Lightmap,\n"
2973 "#endif\n"
2974 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
2975 "uniform sampler2D Texture_Deluxemap,\n"
2976 "#endif\n"
2977 "#ifdef USEREFLECTION\n"
2978 "uniform sampler2D Texture_Reflection,\n"
2979 "#endif\n"
2980 "\n"
2981 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
2982 "uniform sampler2D Texture_ScreenDepth,\n"
2983 "uniform sampler2D Texture_ScreenNormalMap,\n"
2984 "#endif\n"
2985 "#ifdef USEDEFERREDLIGHTMAP\n"
2986 "uniform sampler2D Texture_ScreenDiffuse,\n"
2987 "uniform sampler2D Texture_ScreenSpecular,\n"
2988 "#endif\n"
2989 "\n"
2990 "#ifdef USECOLORMAPPING\n"
2991 "uniform half3 Color_Pants,\n"
2992 "uniform half3 Color_Shirt,\n"
2993 "#endif\n"
2994 "#ifdef USEFOG\n"
2995 "uniform float3 FogColor,\n"
2996 "uniform float FogRangeRecip,\n"
2997 "uniform float FogPlaneViewDist,\n"
2998 "uniform float FogHeightFade,\n"
2999 "#endif\n"
3000 "\n"
3001 "#ifdef USEOFFSETMAPPING\n"
3002 "uniform float OffsetMapping_Scale,\n"
3003 "#endif\n"
3004 "\n"
3005 "#ifdef USEDEFERREDLIGHTMAP\n"
3006 "uniform half2 PixelToScreenTexCoord,\n"
3007 "uniform half3 DeferredMod_Diffuse,\n"
3008 "uniform half3 DeferredMod_Specular,\n"
3009 "#endif\n"
3010 "uniform half3 Color_Ambient,\n"
3011 "uniform half3 Color_Diffuse,\n"
3012 "uniform half3 Color_Specular,\n"
3013 "uniform half SpecularPower,\n"
3014 "#ifdef USEGLOW\n"
3015 "uniform half3 Color_Glow,\n"
3016 "#endif\n"
3017 "uniform half Alpha,\n"
3018 "#ifdef USEREFLECTION\n"
3019 "uniform float4 DistortScaleRefractReflect,\n"
3020 "uniform float4 ScreenScaleRefractReflect,\n"
3021 "uniform float4 ScreenCenterRefractReflect,\n"
3022 "uniform half4 ReflectColor,\n"
3023 "#endif\n"
3024 "#ifdef USEREFLECTCUBE\n"
3025 "uniform float4x4 ModelToReflectCube,\n"
3026 "uniform sampler2D Texture_ReflectMask,\n"
3027 "uniform samplerCUBE Texture_ReflectCube,\n"
3028 "#endif\n"
3029 "#ifdef MODE_LIGHTDIRECTION\n"
3030 "uniform half3 LightColor,\n"
3031 "#endif\n"
3032 "#ifdef MODE_LIGHTSOURCE\n"
3033 "uniform half3 LightColor,\n"
3034 "#endif\n"
3035 "\n"
3036 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n"
3037 "uniform sampler2D Texture_Attenuation,\n"
3038 "uniform samplerCUBE Texture_Cube,\n"
3039 "#endif\n"
3040 "\n"
3041 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n"
3042 "\n"
3043 "#ifdef USESHADOWMAPRECT\n"
3044 "# ifdef USESHADOWSAMPLER\n"
3045 "uniform samplerRECTShadow Texture_ShadowMapRect,\n"
3046 "# else\n"
3047 "uniform samplerRECT Texture_ShadowMapRect,\n"
3048 "# endif\n"
3049 "#endif\n"
3050 "\n"
3051 "#ifdef USESHADOWMAP2D\n"
3052 "# ifdef USESHADOWSAMPLER\n"
3053 "uniform sampler2DShadow Texture_ShadowMap2D,\n"
3054 "# else\n"
3055 "uniform sampler2D Texture_ShadowMap2D,\n"
3056 "# endif\n"
3057 "#endif\n"
3058 "\n"
3059 "#ifdef USESHADOWMAPVSDCT\n"
3060 "uniform samplerCUBE Texture_CubeProjection,\n"
3061 "#endif\n"
3062 "\n"
3063 "#ifdef USESHADOWMAPCUBE\n"
3064 "# ifdef USESHADOWSAMPLER\n"
3065 "uniform samplerCUBEShadow Texture_ShadowMapCube,\n"
3066 "# else\n"
3067 "uniform samplerCUBE Texture_ShadowMapCube,\n"
3068 "# endif\n"
3069 "#endif\n"
3070 "\n"
3071 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D) || defined(USESHADOWMAPCUBE)\n"
3072 "uniform float2 ShadowMap_TextureScale,\n"
3073 "uniform float4 ShadowMap_Parameters,\n"
3074 "#endif\n"
3075 "#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n"
3076 "\n"
3077 "out float4 gl_FragColor : COLOR\n"
3078 ")\n"
3079 "{\n"
3080 "       float2 TexCoord = TexCoordBoth.xy;\n"
3081 "#ifdef USEVERTEXTEXTUREBLEND\n"
3082 "       float2 TexCoord2 = TexCoordBoth.zw;\n"
3083 "#endif\n"
3084 "#ifdef USEOFFSETMAPPING\n"
3085 "       // apply offsetmapping\n"
3086 "       float2 TexCoordOffset = OffsetMapping(TexCoord, OffsetMapping_Scale, EyeVector, Texture_Normal);\n"
3087 "#define TexCoord TexCoordOffset\n"
3088 "#endif\n"
3089 "\n"
3090 "       // combine the diffuse textures (base, pants, shirt)\n"
3091 "       half4 color = half4(tex2D(Texture_Color, TexCoord));\n"
3092 "#ifdef USEALPHAKILL\n"
3093 "       if (color.a < 0.5)\n"
3094 "               discard;\n"
3095 "#endif\n"
3096 "       color.a *= Alpha;\n"
3097 "#ifdef USECOLORMAPPING\n"
3098 "       color.rgb += half3(tex2D(Texture_Pants, TexCoord)) * Color_Pants + half3(tex2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
3099 "#endif\n"
3100 "#ifdef USEVERTEXTEXTUREBLEND\n"
3101 "       float terrainblend = clamp(half(gl_FrontColor.a) * color.a * 2.0 - 0.5, half(0.0), half(1.0));\n"
3102 "       //half terrainblend = min(half(gl_FrontColor.a) * color.a * 2.0, half(1.0));\n"
3103 "       //half terrainblend = half(gl_FrontColor.a) * color.a > 0.5;\n"
3104 "       color.rgb = half3(lerp(float3(tex2D(Texture_SecondaryColor, TexCoord2)), float3(color.rgb), terrainblend));\n"
3105 "       color.a = 1.0;\n"
3106 "       //color = lerp(half4(1, 0, 0, 1), color, terrainblend);\n"
3107 "#endif\n"
3108 "\n"
3109 "       // get the surface normal\n"
3110 "#ifdef USEVERTEXTEXTUREBLEND\n"
3111 "       half3 surfacenormal = normalize(half3(lerp(float3(tex2D(Texture_SecondaryNormal, TexCoord2)), float3(tex2D(Texture_Normal, TexCoord)), terrainblend)) - half3(0.5, 0.5, 0.5));\n"
3112 "#else\n"
3113 "       half3 surfacenormal = normalize(half3(tex2D(Texture_Normal, TexCoord)) - half3(0.5, 0.5, 0.5));\n"
3114 "#endif\n"
3115 "\n"
3116 "       // get the material colors\n"
3117 "       half3 diffusetex = color.rgb;\n"
3118 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
3119 "# ifdef USEVERTEXTEXTUREBLEND\n"
3120 "       half4 glosstex = half4(lerp(float4(tex2D(Texture_SecondaryGloss, TexCoord2)), float4(tex2D(Texture_Gloss, TexCoord)), terrainblend));\n"
3121 "# else\n"
3122 "       half4 glosstex = half4(tex2D(Texture_Gloss, TexCoord));\n"
3123 "# endif\n"
3124 "#endif\n"
3125 "\n"
3126 "#ifdef USEREFLECTCUBE\n"
3127 "       float3 TangentReflectVector = reflect(-EyeVector, surfacenormal);\n"
3128 "       float3 ModelReflectVector = TangentReflectVector.x * VectorS + TangentReflectVector.y * VectorT + TangentReflectVector.z * VectorR;\n"
3129 "       float3 ReflectCubeTexCoord = float3(mul(ModelToReflectCube, float4(ModelReflectVector, 0)));\n"
3130 "       diffusetex += half3(tex2D(Texture_ReflectMask, TexCoord)) * half3(texCUBE(Texture_ReflectCube, ReflectCubeTexCoord));\n"
3131 "#endif\n"
3132 "\n"
3133 "\n"
3134 "\n"
3135 "\n"
3136 "#ifdef MODE_LIGHTSOURCE\n"
3137 "       // light source\n"
3138 "#ifdef USEDIFFUSE\n"
3139 "       half3 lightnormal = half3(normalize(LightVector));\n"
3140 "       half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
3141 "       color.rgb = diffusetex * (Color_Ambient + diffuse * Color_Diffuse);\n"
3142 "#ifdef USESPECULAR\n"
3143 "#ifdef USEEXACTSPECULARMATH\n"
3144 "       half specular = pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n"
3145 "#else\n"
3146 "       half3 specularnormal = normalize(lightnormal + half3(normalize(EyeVector)));\n"
3147 "       half specular = pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n"
3148 "#endif\n"
3149 "       color.rgb += glosstex.rgb * (specular * Color_Specular);\n"
3150 "#endif\n"
3151 "#else\n"
3152 "       color.rgb = diffusetex * Color_Ambient;\n"
3153 "#endif\n"
3154 "       color.rgb *= LightColor;\n"
3155 "       color.rgb *= half(tex2D(Texture_Attenuation, float2(length(CubeVector), 0.0)));\n"
3156 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAPCUBE) || defined(USESHADOWMAP2D)\n"
3157 "       color.rgb *= ShadowMapCompare(CubeVector,\n"
3158 "# if defined(USESHADOWMAP2D)\n"
3159 "Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n"
3160 "# endif\n"
3161 "# if defined(USESHADOWMAPRECT)\n"
3162 "Texture_ShadowMapRect, ShadowMap_Parameters\n"
3163 "# endif\n"
3164 "# if defined(USESHADOWMAPCUBE)\n"
3165 "Texture_ShadowMapCube, ShadowMap_Parameters\n"
3166 "# endif\n"
3167 "\n"
3168 "#ifdef USESHADOWMAPVSDCT\n"
3169 ", Texture_CubeProjection\n"
3170 "#endif\n"
3171 "       );\n"
3172 "\n"
3173 "#endif\n"
3174 "# ifdef USECUBEFILTER\n"
3175 "       color.rgb *= half3(texCUBE(Texture_Cube, CubeVector));\n"
3176 "# endif\n"
3177 "#endif // MODE_LIGHTSOURCE\n"
3178 "\n"
3179 "\n"
3180 "\n"
3181 "\n"
3182 "#ifdef MODE_LIGHTDIRECTION\n"
3183 "#define SHADING\n"
3184 "#ifdef USEDIFFUSE\n"
3185 "       half3 lightnormal = half3(normalize(LightVector));\n"
3186 "#endif\n"
3187 "#define lightcolor LightColor\n"
3188 "#endif // MODE_LIGHTDIRECTION\n"
3189 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
3190 "#define SHADING\n"
3191 "       // deluxemap lightmapping using light vectors in modelspace (q3map2 -light -deluxe)\n"
3192 "       half3 lightnormal_modelspace = half3(tex2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + half3(-1.0, -1.0, -1.0);\n"
3193 "       half3 lightcolor = half3(tex2D(Texture_Lightmap, TexCoordLightmap));\n"
3194 "       // convert modelspace light vector to tangentspace\n"
3195 "       half3 lightnormal;\n"
3196 "       lightnormal.x = dot(lightnormal_modelspace, half3(VectorS));\n"
3197 "       lightnormal.y = dot(lightnormal_modelspace, half3(VectorT));\n"
3198 "       lightnormal.z = dot(lightnormal_modelspace, half3(VectorR));\n"
3199 "       // calculate directional shading (and undoing the existing angle attenuation on the lightmap by the division)\n"
3200 "       // note that q3map2 is too stupid to calculate proper surface normals when q3map_nonplanar\n"
3201 "       // is used (the lightmap and deluxemap coords correspond to virtually random coordinates\n"
3202 "       // on that luxel, and NOT to its center, because recursive triangle subdivision is used\n"
3203 "       // to map the luxels to coordinates on the draw surfaces), which also causes\n"
3204 "       // deluxemaps to be wrong because light contributions from the wrong side of the surface\n"
3205 "       // are added up. To prevent divisions by zero or strong exaggerations, a max()\n"
3206 "       // nudge is done here at expense of some additional fps. This is ONLY needed for\n"
3207 "       // deluxemaps, tangentspace deluxemap avoid this problem by design.\n"
3208 "       lightcolor *= 1.0 / max(0.25, lightnormal.z);\n"
3209 "#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
3210 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
3211 "#define SHADING\n"
3212 "       // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
3213 "       half3 lightnormal = half3(tex2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + half3(-1.0, -1.0, -1.0);\n"
3214 "       half3 lightcolor = half3(tex2D(Texture_Lightmap, TexCoordLightmap));\n"
3215 "#endif\n"
3216 "\n"
3217 "\n"
3218 "\n"
3219 "\n"
3220 "#ifdef MODE_LIGHTMAP\n"
3221 "       color.rgb = diffusetex * (Color_Ambient + half3(tex2D(Texture_Lightmap, TexCoordLightmap)) * Color_Diffuse);\n"
3222 "#endif // MODE_LIGHTMAP\n"
3223 "#ifdef MODE_VERTEXCOLOR\n"
3224 "       color.rgb = diffusetex * (Color_Ambient + half3(gl_FrontColor.rgb) * Color_Diffuse);\n"
3225 "#endif // MODE_VERTEXCOLOR\n"
3226 "#ifdef MODE_FLATCOLOR\n"
3227 "       color.rgb = diffusetex * Color_Ambient;\n"
3228 "#endif // MODE_FLATCOLOR\n"
3229 "\n"
3230 "\n"
3231 "\n"
3232 "\n"
3233 "#ifdef SHADING\n"
3234 "# ifdef USEDIFFUSE\n"
3235 "       half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
3236 "#  ifdef USESPECULAR\n"
3237 "#   ifdef USEEXACTSPECULARMATH\n"
3238 "       half specular = pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n"
3239 "#   else\n"
3240 "       half3 specularnormal = normalize(lightnormal + half3(normalize(EyeVector)));\n"
3241 "       half specular = pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n"
3242 "#   endif\n"
3243 "       color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex.rgb * Color_Specular * specular) * lightcolor;\n"
3244 "#  else\n"
3245 "       color.rgb = diffusetex * (Color_Ambient + Color_Diffuse * diffuse * lightcolor);\n"
3246 "#  endif\n"
3247 "# else\n"
3248 "       color.rgb = diffusetex * Color_Ambient;\n"
3249 "# endif\n"
3250 "#endif\n"
3251 "\n"
3252 "#ifdef USESHADOWMAPORTHO\n"
3253 "       color.rgb *= ShadowMapCompare(ShadowMapTC,\n"
3254 "# if defined(USESHADOWMAP2D)\n"
3255 "Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n"
3256 "# endif\n"
3257 "# if defined(USESHADOWMAPRECT)\n"
3258 "Texture_ShadowMapRect, ShadowMap_Parameters\n"
3259 "# endif\n"
3260 "       );\n"
3261 "#endif\n"
3262 "\n"
3263 "#ifdef USEDEFERREDLIGHTMAP\n"
3264 "       float2 ScreenTexCoord = Pixel * PixelToScreenTexCoord;\n"
3265 "       color.rgb += diffusetex * half3(tex2D(Texture_ScreenDiffuse, ScreenTexCoord)) * DeferredMod_Diffuse;\n"
3266 "       color.rgb += glosstex.rgb * half3(tex2D(Texture_ScreenSpecular, ScreenTexCoord)) * DeferredMod_Specular;\n"
3267 "#endif\n"
3268 "\n"
3269 "#ifdef USEGLOW\n"
3270 "#ifdef USEVERTEXTEXTUREBLEND\n"
3271 "       color.rgb += lerp(half3(tex2D(Texture_SecondaryGlow, TexCoord2)), half3(tex2D(Texture_Glow, TexCoord)), terrainblend) * Color_Glow;\n"
3272 "#else\n"
3273 "       color.rgb += half3(tex2D(Texture_Glow, TexCoord)) * Color_Glow;\n"
3274 "#endif\n"
3275 "#endif\n"
3276 "\n"
3277 "#ifdef USEFOG\n"
3278 "       color.rgb = FogVertex(color.rgb, FogColor, EyeVectorModelSpaceFogPlaneVertexDist.xyz, EyeVectorModelSpaceFogPlaneVertexDist.w, FogRangeRecip, FogPlaneViewDist, FogHeightFade, Texture_FogMask, Texture_FogHeightTexture);\n"
3279 "#endif\n"
3280 "\n"
3281 "       // 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"
3282 "#ifdef USEREFLECTION\n"
3283 "       float4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
3284 "       //float4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(half3(tex2D(Texture_Normal, TexCoord)) - half3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
3285 "       float2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW.zw + ScreenCenterRefractReflect.zw;\n"
3286 "       float2 ScreenTexCoord = SafeScreenTexCoord + float3(normalize(half3(tex2D(Texture_Normal, TexCoord)) - half3(0.5))).xy * DistortScaleRefractReflect.zw;\n"
3287 "       // FIXME temporary hack to detect the case that the reflection\n"
3288 "       // gets blackened at edges due to leaving the area that contains actual\n"
3289 "       // content.\n"
3290 "       // Remove this 'ack once we have a better way to stop this thing from\n"
3291 "       // 'appening.\n"
3292 "       float f = min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(0.01, 0.01)).rgb) / 0.05);\n"
3293 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(0.01, -0.01)).rgb) / 0.05);\n"
3294 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(-0.01, 0.01)).rgb) / 0.05);\n"
3295 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(-0.01, -0.01)).rgb) / 0.05);\n"
3296 "       ScreenTexCoord = lerp(SafeScreenTexCoord, ScreenTexCoord, f);\n"
3297 "       color.rgb = lerp(color.rgb, half3(tex2D(Texture_Reflection, ScreenTexCoord)) * ReflectColor.rgb, ReflectColor.a);\n"
3298 "#endif\n"
3299 "\n"
3300 "       gl_FragColor = float4(color);\n"
3301 "}\n"
3302 "#endif // FRAGMENT_SHADER\n"
3303 "\n"
3304 "#endif // !MODE_DEFERREDLIGHTSOURCE\n"
3305 "#endif // !MODE_DEFERREDGEOMETRY\n"
3306 "#endif // !MODE_WATER\n"
3307 "#endif // !MODE_REFRACTION\n"
3308 "#endif // !MODE_BLOOMBLUR\n"
3309 "#endif // !MODE_GENERIC\n"
3310 "#endif // !MODE_POSTPROCESS\n"
3311 "#endif // !MODE_SHOWDEPTH\n"
3312 "#endif // !MODE_DEPTH_OR_SHADOW\n"
3313 ;
3314
3315 char *glslshaderstring = NULL;
3316 char *cgshaderstring = NULL;
3317
3318 //=======================================================================================================================================================
3319
3320 typedef struct shaderpermutationinfo_s
3321 {
3322         const char *pretext;
3323         const char *name;
3324 }
3325 shaderpermutationinfo_t;
3326
3327 typedef struct shadermodeinfo_s
3328 {
3329         const char *vertexfilename;
3330         const char *geometryfilename;
3331         const char *fragmentfilename;
3332         const char *pretext;
3333         const char *name;
3334 }
3335 shadermodeinfo_t;
3336
3337 typedef enum shaderpermutation_e
3338 {
3339         SHADERPERMUTATION_DIFFUSE = 1<<0, ///< (lightsource) whether to use directional shading
3340         SHADERPERMUTATION_VERTEXTEXTUREBLEND = 1<<1, ///< indicates this is a two-layer material blend based on vertex alpha (q3bsp)
3341         SHADERPERMUTATION_VIEWTINT = 1<<2, ///< view tint (postprocessing only)
3342         SHADERPERMUTATION_COLORMAPPING = 1<<3, ///< indicates this is a colormapped skin
3343         SHADERPERMUTATION_SATURATION = 1<<4, ///< saturation (postprocessing only)
3344         SHADERPERMUTATION_FOGINSIDE = 1<<5, ///< tint the color by fog color or black if using additive blend mode
3345         SHADERPERMUTATION_FOGOUTSIDE = 1<<6, ///< tint the color by fog color or black if using additive blend mode
3346         SHADERPERMUTATION_FOGHEIGHTTEXTURE = 1<<7, ///< fog color and density determined by texture mapped on vertical axis
3347         SHADERPERMUTATION_GAMMARAMPS = 1<<8, ///< gamma (postprocessing only)
3348         SHADERPERMUTATION_CUBEFILTER = 1<<9, ///< (lightsource) use cubemap light filter
3349         SHADERPERMUTATION_GLOW = 1<<10, ///< (lightmap) blend in an additive glow texture
3350         SHADERPERMUTATION_BLOOM = 1<<11, ///< bloom (postprocessing only)
3351         SHADERPERMUTATION_SPECULAR = 1<<12, ///< (lightsource or deluxemapping) render specular effects
3352         SHADERPERMUTATION_POSTPROCESSING = 1<<13, ///< user defined postprocessing (postprocessing only)
3353         SHADERPERMUTATION_EXACTSPECULARMATH = 1<<14, ///< (lightsource or deluxemapping) use exact reflection map for specular effects, as opposed to the usual OpenGL approximation
3354         SHADERPERMUTATION_REFLECTION = 1<<15, ///< normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface
3355         SHADERPERMUTATION_OFFSETMAPPING = 1<<16, ///< adjust texcoords to roughly simulate a displacement mapped surface
3356         SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING = 1<<17, ///< adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!)
3357         SHADERPERMUTATION_SHADOWMAPRECT = 1<<18, ///< (lightsource) use shadowmap rectangle texture as light filter
3358         SHADERPERMUTATION_SHADOWMAPCUBE = 1<<19, ///< (lightsource) use shadowmap cubemap texture as light filter
3359         SHADERPERMUTATION_SHADOWMAP2D = 1<<20, ///< (lightsource) use shadowmap rectangle texture as light filter
3360         SHADERPERMUTATION_SHADOWMAPPCF = 1<<21, ///< (lightsource) use percentage closer filtering on shadowmap test results
3361         SHADERPERMUTATION_SHADOWMAPPCF2 = 1<<22, ///< (lightsource) use higher quality percentage closer filtering on shadowmap test results
3362         SHADERPERMUTATION_SHADOWSAMPLER = 1<<23, ///< (lightsource) use hardware shadowmap test
3363         SHADERPERMUTATION_SHADOWMAPVSDCT = 1<<24, ///< (lightsource) use virtual shadow depth cube texture for shadowmap indexing
3364         SHADERPERMUTATION_SHADOWMAPORTHO = 1<<25, //< (lightsource) use orthographic shadowmap projection
3365         SHADERPERMUTATION_DEFERREDLIGHTMAP = 1<<26, ///< (lightmap) read Texture_ScreenDiffuse/Specular textures and add them on top of lightmapping
3366         SHADERPERMUTATION_ALPHAKILL = 1<<27, ///< (deferredgeometry) discard pixel if diffuse texture alpha below 0.5
3367         SHADERPERMUTATION_REFLECTCUBE = 1<<28, ///< fake reflections using global cubemap (not HDRI light probe)
3368         SHADERPERMUTATION_LIMIT = 1<<29, ///< size of permutations array
3369         SHADERPERMUTATION_COUNT = 29 ///< size of shaderpermutationinfo array
3370 }
3371 shaderpermutation_t;
3372
3373 // NOTE: MUST MATCH ORDER OF SHADERPERMUTATION_* DEFINES!
3374 shaderpermutationinfo_t shaderpermutationinfo[SHADERPERMUTATION_COUNT] =
3375 {
3376         {"#define USEDIFFUSE\n", " diffuse"},
3377         {"#define USEVERTEXTEXTUREBLEND\n", " vertextextureblend"},
3378         {"#define USEVIEWTINT\n", " viewtint"},
3379         {"#define USECOLORMAPPING\n", " colormapping"},
3380         {"#define USESATURATION\n", " saturation"},
3381         {"#define USEFOGINSIDE\n", " foginside"},
3382         {"#define USEFOGOUTSIDE\n", " fogoutside"},
3383         {"#define USEFOGHEIGHTTEXTURE\n", " fogheighttexture"},
3384         {"#define USEGAMMARAMPS\n", " gammaramps"},
3385         {"#define USECUBEFILTER\n", " cubefilter"},
3386         {"#define USEGLOW\n", " glow"},
3387         {"#define USEBLOOM\n", " bloom"},
3388         {"#define USESPECULAR\n", " specular"},
3389         {"#define USEPOSTPROCESSING\n", " postprocessing"},
3390         {"#define USEEXACTSPECULARMATH\n", " exactspecularmath"},
3391         {"#define USEREFLECTION\n", " reflection"},
3392         {"#define USEOFFSETMAPPING\n", " offsetmapping"},
3393         {"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"},
3394         {"#define USESHADOWMAPRECT\n", " shadowmaprect"},
3395         {"#define USESHADOWMAPCUBE\n", " shadowmapcube"},
3396         {"#define USESHADOWMAP2D\n", " shadowmap2d"},
3397         {"#define USESHADOWMAPPCF 1\n", " shadowmappcf"},
3398         {"#define USESHADOWMAPPCF 2\n", " shadowmappcf2"},
3399         {"#define USESHADOWSAMPLER\n", " shadowsampler"},
3400         {"#define USESHADOWMAPVSDCT\n", " shadowmapvsdct"},
3401         {"#define USESHADOWMAPORTHO\n", " shadowmaportho"},
3402         {"#define USEDEFERREDLIGHTMAP\n", " deferredlightmap"},
3403         {"#define USEALPHAKILL\n", " alphakill"},
3404         {"#define USEREFLECTCUBE\n", " reflectcube"},
3405 };
3406
3407 /// this enum is multiplied by SHADERPERMUTATION_MODEBASE
3408 typedef enum shadermode_e
3409 {
3410         SHADERMODE_GENERIC, ///< (particles/HUD/etc) vertex color, optionally multiplied by one texture
3411         SHADERMODE_POSTPROCESS, ///< postprocessing shader (r_glsl_postprocess)
3412         SHADERMODE_DEPTH_OR_SHADOW, ///< (depthfirst/shadows) vertex shader only
3413         SHADERMODE_FLATCOLOR, ///< (lightmap) modulate texture by uniform color (q1bsp, q3bsp)
3414         SHADERMODE_VERTEXCOLOR, ///< (lightmap) modulate texture by vertex colors (q3bsp)
3415         SHADERMODE_LIGHTMAP, ///< (lightmap) modulate texture by lightmap texture (q1bsp, q3bsp)
3416         SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE, ///< (lightmap) use directional pixel shading from texture containing modelspace light directions (q3bsp deluxemap)
3417         SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE, ///< (lightmap) use directional pixel shading from texture containing tangentspace light directions (q1bsp deluxemap)
3418         SHADERMODE_LIGHTDIRECTION, ///< (lightmap) use directional pixel shading from fixed light direction (q3bsp)
3419         SHADERMODE_LIGHTSOURCE, ///< (lightsource) use directional pixel shading from light source (rtlight)
3420         SHADERMODE_REFRACTION, ///< refract background (the material is rendered normally after this pass)
3421         SHADERMODE_WATER, ///< refract background and reflection (the material is rendered normally after this pass)
3422         SHADERMODE_SHOWDEPTH, ///< (debugging) renders depth as color
3423         SHADERMODE_DEFERREDGEOMETRY, ///< (deferred) render material properties to screenspace geometry buffers
3424         SHADERMODE_DEFERREDLIGHTSOURCE, ///< (deferred) use directional pixel shading from light source (rtlight) on screenspace geometry buffers
3425         SHADERMODE_COUNT
3426 }
3427 shadermode_t;
3428
3429 // NOTE: MUST MATCH ORDER OF SHADERMODE_* ENUMS!
3430 shadermodeinfo_t glslshadermodeinfo[SHADERMODE_COUNT] =
3431 {
3432         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_GENERIC\n", " generic"},
3433         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_POSTPROCESS\n", " postprocess"},
3434         {"glsl/default.glsl", NULL, NULL               , "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"},
3435         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_FLATCOLOR\n", " flatcolor"},
3436         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
3437         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTMAP\n", " lightmap"},
3438         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
3439         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
3440         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
3441         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTSOURCE\n", " lightsource"},
3442         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_REFRACTION\n", " refraction"},
3443         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_WATER\n", " water"},
3444         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_SHOWDEPTH\n", " showdepth"},
3445         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
3446         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
3447 };
3448
3449 #ifdef SUPPORTCG
3450 shadermodeinfo_t cgshadermodeinfo[SHADERMODE_COUNT] =
3451 {
3452         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_GENERIC\n", " generic"},
3453         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_POSTPROCESS\n", " postprocess"},
3454         {"cg/default.cg", NULL, NULL           , "#define MODE_DEPTH_OR_SHADOW\n", " depth"},
3455         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_FLATCOLOR\n", " flatcolor"},
3456         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
3457         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTMAP\n", " lightmap"},
3458         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
3459         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
3460         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
3461         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTSOURCE\n", " lightsource"},
3462         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_REFRACTION\n", " refraction"},
3463         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_WATER\n", " water"},
3464         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_SHOWDEPTH\n", " showdepth"},
3465         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
3466         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
3467 };
3468 #endif
3469
3470 struct r_glsl_permutation_s;
3471 typedef struct r_glsl_permutation_s
3472 {
3473         /// hash lookup data
3474         struct r_glsl_permutation_s *hashnext;
3475         unsigned int mode;
3476         unsigned int permutation;
3477
3478         /// indicates if we have tried compiling this permutation already
3479         qboolean compiled;
3480         /// 0 if compilation failed
3481         int program;
3482         /// locations of detected uniforms in program object, or -1 if not found
3483         int loc_Texture_First;
3484         int loc_Texture_Second;
3485         int loc_Texture_GammaRamps;
3486         int loc_Texture_Normal;
3487         int loc_Texture_Color;
3488         int loc_Texture_Gloss;
3489         int loc_Texture_Glow;
3490         int loc_Texture_SecondaryNormal;
3491         int loc_Texture_SecondaryColor;
3492         int loc_Texture_SecondaryGloss;
3493         int loc_Texture_SecondaryGlow;
3494         int loc_Texture_Pants;
3495         int loc_Texture_Shirt;
3496         int loc_Texture_FogHeightTexture;
3497         int loc_Texture_FogMask;
3498         int loc_Texture_Lightmap;
3499         int loc_Texture_Deluxemap;
3500         int loc_Texture_Attenuation;
3501         int loc_Texture_Cube;
3502         int loc_Texture_Refraction;
3503         int loc_Texture_Reflection;
3504         int loc_Texture_ShadowMapRect;
3505         int loc_Texture_ShadowMapCube;
3506         int loc_Texture_ShadowMap2D;
3507         int loc_Texture_CubeProjection;
3508         int loc_Texture_ScreenDepth;
3509         int loc_Texture_ScreenNormalMap;
3510         int loc_Texture_ScreenDiffuse;
3511         int loc_Texture_ScreenSpecular;
3512         int loc_Texture_ReflectMask;
3513         int loc_Texture_ReflectCube;
3514         int loc_Alpha;
3515         int loc_BloomBlur_Parameters;
3516         int loc_ClientTime;
3517         int loc_Color_Ambient;
3518         int loc_Color_Diffuse;
3519         int loc_Color_Specular;
3520         int loc_Color_Glow;
3521         int loc_Color_Pants;
3522         int loc_Color_Shirt;
3523         int loc_DeferredColor_Ambient;
3524         int loc_DeferredColor_Diffuse;
3525         int loc_DeferredColor_Specular;
3526         int loc_DeferredMod_Diffuse;
3527         int loc_DeferredMod_Specular;
3528         int loc_DistortScaleRefractReflect;
3529         int loc_EyePosition;
3530         int loc_FogColor;
3531         int loc_FogHeightFade;
3532         int loc_FogPlane;
3533         int loc_FogPlaneViewDist;
3534         int loc_FogRangeRecip;
3535         int loc_LightColor;
3536         int loc_LightDir;
3537         int loc_LightPosition;
3538         int loc_OffsetMapping_Scale;
3539         int loc_PixelSize;
3540         int loc_ReflectColor;
3541         int loc_ReflectFactor;
3542         int loc_ReflectOffset;
3543         int loc_RefractColor;
3544         int loc_Saturation;
3545         int loc_ScreenCenterRefractReflect;
3546         int loc_ScreenScaleRefractReflect;
3547         int loc_ScreenToDepth;
3548         int loc_ShadowMap_Parameters;
3549         int loc_ShadowMap_TextureScale;
3550         int loc_SpecularPower;
3551         int loc_UserVec1;
3552         int loc_UserVec2;
3553         int loc_UserVec3;
3554         int loc_UserVec4;
3555         int loc_ViewTintColor;
3556         int loc_ViewToLight;
3557         int loc_ModelToLight;
3558         int loc_TexMatrix;
3559         int loc_BackgroundTexMatrix;
3560         int loc_ModelViewProjectionMatrix;
3561         int loc_ModelViewMatrix;
3562         int loc_PixelToScreenTexCoord;
3563         int loc_ModelToReflectCube;
3564         int loc_ShadowMapMatrix;
3565 }
3566 r_glsl_permutation_t;
3567
3568 #define SHADERPERMUTATION_HASHSIZE 256
3569
3570 /// information about each possible shader permutation
3571 r_glsl_permutation_t *r_glsl_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
3572 /// currently selected permutation
3573 r_glsl_permutation_t *r_glsl_permutation;
3574 /// storage for permutations linked in the hash table
3575 memexpandablearray_t r_glsl_permutationarray;
3576
3577 static r_glsl_permutation_t *R_GLSL_FindPermutation(unsigned int mode, unsigned int permutation)
3578 {
3579         //unsigned int hashdepth = 0;
3580         unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
3581         r_glsl_permutation_t *p;
3582         for (p = r_glsl_permutationhash[mode][hashindex];p;p = p->hashnext)
3583         {
3584                 if (p->mode == mode && p->permutation == permutation)
3585                 {
3586                         //if (hashdepth > 10)
3587                         //      Con_Printf("R_GLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
3588                         return p;
3589                 }
3590                 //hashdepth++;
3591         }
3592         p = (r_glsl_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_glsl_permutationarray);
3593         p->mode = mode;
3594         p->permutation = permutation;
3595         p->hashnext = r_glsl_permutationhash[mode][hashindex];
3596         r_glsl_permutationhash[mode][hashindex] = p;
3597         //if (hashdepth > 10)
3598         //      Con_Printf("R_GLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
3599         return p;
3600 }
3601
3602 static char *R_GLSL_GetText(const char *filename, qboolean printfromdisknotice)
3603 {
3604         char *shaderstring;
3605         if (!filename || !filename[0])
3606                 return NULL;
3607         if (!strcmp(filename, "glsl/default.glsl"))
3608         {
3609                 if (!glslshaderstring)
3610                 {
3611                         glslshaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
3612                         if (glslshaderstring)
3613                                 Con_DPrintf("Loading shaders from file %s...\n", filename);
3614                         else
3615                                 glslshaderstring = (char *)builtinshaderstring;
3616                 }
3617                 shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(glslshaderstring) + 1);
3618                 memcpy(shaderstring, glslshaderstring, strlen(glslshaderstring) + 1);
3619                 return shaderstring;
3620         }
3621         shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
3622         if (shaderstring)
3623         {
3624                 if (printfromdisknotice)
3625                         Con_DPrintf("from disk %s... ", filename);
3626                 return shaderstring;
3627         }
3628         return shaderstring;
3629 }
3630
3631 static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode, unsigned int permutation)
3632 {
3633         int i;
3634         shadermodeinfo_t *modeinfo = glslshadermodeinfo + mode;
3635         int vertstrings_count = 0;
3636         int geomstrings_count = 0;
3637         int fragstrings_count = 0;
3638         char *vertexstring, *geometrystring, *fragmentstring;
3639         const char *vertstrings_list[32+3];
3640         const char *geomstrings_list[32+3];
3641         const char *fragstrings_list[32+3];
3642         char permutationname[256];
3643
3644         if (p->compiled)
3645                 return;
3646         p->compiled = true;
3647         p->program = 0;
3648
3649         permutationname[0] = 0;
3650         vertexstring   = R_GLSL_GetText(modeinfo->vertexfilename, true);
3651         geometrystring = R_GLSL_GetText(modeinfo->geometryfilename, false);
3652         fragmentstring = R_GLSL_GetText(modeinfo->fragmentfilename, false);
3653
3654         strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname));
3655
3656         // the first pretext is which type of shader to compile as
3657         // (later these will all be bound together as a program object)
3658         vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
3659         geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
3660         fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
3661
3662         // the second pretext is the mode (for example a light source)
3663         vertstrings_list[vertstrings_count++] = modeinfo->pretext;
3664         geomstrings_list[geomstrings_count++] = modeinfo->pretext;
3665         fragstrings_list[fragstrings_count++] = modeinfo->pretext;
3666         strlcat(permutationname, modeinfo->name, sizeof(permutationname));
3667
3668         // now add all the permutation pretexts
3669         for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
3670         {
3671                 if (permutation & (1<<i))
3672                 {
3673                         vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
3674                         geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
3675                         fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
3676                         strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
3677                 }
3678                 else
3679                 {
3680                         // keep line numbers correct
3681                         vertstrings_list[vertstrings_count++] = "\n";
3682                         geomstrings_list[geomstrings_count++] = "\n";
3683                         fragstrings_list[fragstrings_count++] = "\n";
3684                 }
3685         }
3686
3687         // now append the shader text itself
3688         vertstrings_list[vertstrings_count++] = vertexstring;
3689         geomstrings_list[geomstrings_count++] = geometrystring;
3690         fragstrings_list[fragstrings_count++] = fragmentstring;
3691
3692         // if any sources were NULL, clear the respective list
3693         if (!vertexstring)
3694                 vertstrings_count = 0;
3695         if (!geometrystring)
3696                 geomstrings_count = 0;
3697         if (!fragmentstring)
3698                 fragstrings_count = 0;
3699
3700         // compile the shader program
3701         if (vertstrings_count + geomstrings_count + fragstrings_count)
3702                 p->program = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, geomstrings_count, geomstrings_list, fragstrings_count, fragstrings_list);
3703         if (p->program)
3704         {
3705                 CHECKGLERROR
3706                 qglUseProgramObjectARB(p->program);CHECKGLERROR
3707                 // look up all the uniform variable names we care about, so we don't
3708                 // have to look them up every time we set them
3709
3710                 p->loc_Texture_First              = qglGetUniformLocationARB(p->program, "Texture_First");
3711                 p->loc_Texture_Second             = qglGetUniformLocationARB(p->program, "Texture_Second");
3712                 p->loc_Texture_GammaRamps         = qglGetUniformLocationARB(p->program, "Texture_GammaRamps");
3713                 p->loc_Texture_Normal             = qglGetUniformLocationARB(p->program, "Texture_Normal");
3714                 p->loc_Texture_Color              = qglGetUniformLocationARB(p->program, "Texture_Color");
3715                 p->loc_Texture_Gloss              = qglGetUniformLocationARB(p->program, "Texture_Gloss");
3716                 p->loc_Texture_Glow               = qglGetUniformLocationARB(p->program, "Texture_Glow");
3717                 p->loc_Texture_SecondaryNormal    = qglGetUniformLocationARB(p->program, "Texture_SecondaryNormal");
3718                 p->loc_Texture_SecondaryColor     = qglGetUniformLocationARB(p->program, "Texture_SecondaryColor");
3719                 p->loc_Texture_SecondaryGloss     = qglGetUniformLocationARB(p->program, "Texture_SecondaryGloss");
3720                 p->loc_Texture_SecondaryGlow      = qglGetUniformLocationARB(p->program, "Texture_SecondaryGlow");
3721                 p->loc_Texture_Pants              = qglGetUniformLocationARB(p->program, "Texture_Pants");
3722                 p->loc_Texture_Shirt              = qglGetUniformLocationARB(p->program, "Texture_Shirt");
3723                 p->loc_Texture_FogHeightTexture   = qglGetUniformLocationARB(p->program, "Texture_FogHeightTexture");
3724                 p->loc_Texture_FogMask            = qglGetUniformLocationARB(p->program, "Texture_FogMask");
3725                 p->loc_Texture_Lightmap           = qglGetUniformLocationARB(p->program, "Texture_Lightmap");
3726                 p->loc_Texture_Deluxemap          = qglGetUniformLocationARB(p->program, "Texture_Deluxemap");
3727                 p->loc_Texture_Attenuation        = qglGetUniformLocationARB(p->program, "Texture_Attenuation");
3728                 p->loc_Texture_Cube               = qglGetUniformLocationARB(p->program, "Texture_Cube");
3729                 p->loc_Texture_Refraction         = qglGetUniformLocationARB(p->program, "Texture_Refraction");
3730                 p->loc_Texture_Reflection         = qglGetUniformLocationARB(p->program, "Texture_Reflection");
3731                 p->loc_Texture_ShadowMapRect      = qglGetUniformLocationARB(p->program, "Texture_ShadowMapRect");
3732                 p->loc_Texture_ShadowMapCube      = qglGetUniformLocationARB(p->program, "Texture_ShadowMapCube");
3733                 p->loc_Texture_ShadowMap2D        = qglGetUniformLocationARB(p->program, "Texture_ShadowMap2D");
3734                 p->loc_Texture_CubeProjection     = qglGetUniformLocationARB(p->program, "Texture_CubeProjection");
3735                 p->loc_Texture_ScreenDepth        = qglGetUniformLocationARB(p->program, "Texture_ScreenDepth");
3736                 p->loc_Texture_ScreenNormalMap    = qglGetUniformLocationARB(p->program, "Texture_ScreenNormalMap");
3737                 p->loc_Texture_ScreenDiffuse      = qglGetUniformLocationARB(p->program, "Texture_ScreenDiffuse");
3738                 p->loc_Texture_ScreenSpecular     = qglGetUniformLocationARB(p->program, "Texture_ScreenSpecular");
3739                 p->loc_Texture_ReflectMask        = qglGetUniformLocationARB(p->program, "Texture_ReflectMask");
3740                 p->loc_Texture_ReflectCube        = qglGetUniformLocationARB(p->program, "Texture_ReflectCube");
3741                 p->loc_Alpha                      = qglGetUniformLocationARB(p->program, "Alpha");
3742                 p->loc_BloomBlur_Parameters       = qglGetUniformLocationARB(p->program, "BloomBlur_Parameters");
3743                 p->loc_ClientTime                 = qglGetUniformLocationARB(p->program, "ClientTime");
3744                 p->loc_Color_Ambient              = qglGetUniformLocationARB(p->program, "Color_Ambient");
3745                 p->loc_Color_Diffuse              = qglGetUniformLocationARB(p->program, "Color_Diffuse");
3746                 p->loc_Color_Specular             = qglGetUniformLocationARB(p->program, "Color_Specular");
3747                 p->loc_Color_Glow                 = qglGetUniformLocationARB(p->program, "Color_Glow");
3748                 p->loc_Color_Pants                = qglGetUniformLocationARB(p->program, "Color_Pants");
3749                 p->loc_Color_Shirt                = qglGetUniformLocationARB(p->program, "Color_Shirt");
3750                 p->loc_DeferredColor_Ambient      = qglGetUniformLocationARB(p->program, "DeferredColor_Ambient");
3751                 p->loc_DeferredColor_Diffuse      = qglGetUniformLocationARB(p->program, "DeferredColor_Diffuse");
3752                 p->loc_DeferredColor_Specular     = qglGetUniformLocationARB(p->program, "DeferredColor_Specular");
3753                 p->loc_DeferredMod_Diffuse        = qglGetUniformLocationARB(p->program, "DeferredMod_Diffuse");
3754                 p->loc_DeferredMod_Specular       = qglGetUniformLocationARB(p->program, "DeferredMod_Specular");
3755                 p->loc_DistortScaleRefractReflect = qglGetUniformLocationARB(p->program, "DistortScaleRefractReflect");
3756                 p->loc_EyePosition                = qglGetUniformLocationARB(p->program, "EyePosition");
3757                 p->loc_FogColor                   = qglGetUniformLocationARB(p->program, "FogColor");
3758                 p->loc_FogHeightFade              = qglGetUniformLocationARB(p->program, "FogHeightFade");
3759                 p->loc_FogPlane                   = qglGetUniformLocationARB(p->program, "FogPlane");
3760                 p->loc_FogPlaneViewDist           = qglGetUniformLocationARB(p->program, "FogPlaneViewDist");
3761                 p->loc_FogRangeRecip              = qglGetUniformLocationARB(p->program, "FogRangeRecip");
3762                 p->loc_LightColor                 = qglGetUniformLocationARB(p->program, "LightColor");
3763                 p->loc_LightDir                   = qglGetUniformLocationARB(p->program, "LightDir");
3764                 p->loc_LightPosition              = qglGetUniformLocationARB(p->program, "LightPosition");
3765                 p->loc_OffsetMapping_Scale        = qglGetUniformLocationARB(p->program, "OffsetMapping_Scale");
3766                 p->loc_PixelSize                  = qglGetUniformLocationARB(p->program, "PixelSize");
3767                 p->loc_ReflectColor               = qglGetUniformLocationARB(p->program, "ReflectColor");
3768                 p->loc_ReflectFactor              = qglGetUniformLocationARB(p->program, "ReflectFactor");
3769                 p->loc_ReflectOffset              = qglGetUniformLocationARB(p->program, "ReflectOffset");
3770                 p->loc_RefractColor               = qglGetUniformLocationARB(p->program, "RefractColor");
3771                 p->loc_Saturation                 = qglGetUniformLocationARB(p->program, "Saturation");
3772                 p->loc_ScreenCenterRefractReflect = qglGetUniformLocationARB(p->program, "ScreenCenterRefractReflect");
3773                 p->loc_ScreenScaleRefractReflect  = qglGetUniformLocationARB(p->program, "ScreenScaleRefractReflect");
3774                 p->loc_ScreenToDepth              = qglGetUniformLocationARB(p->program, "ScreenToDepth");
3775                 p->loc_ShadowMap_Parameters       = qglGetUniformLocationARB(p->program, "ShadowMap_Parameters");
3776                 p->loc_ShadowMap_TextureScale     = qglGetUniformLocationARB(p->program, "ShadowMap_TextureScale");
3777                 p->loc_SpecularPower              = qglGetUniformLocationARB(p->program, "SpecularPower");
3778                 p->loc_UserVec1                   = qglGetUniformLocationARB(p->program, "UserVec1");
3779                 p->loc_UserVec2                   = qglGetUniformLocationARB(p->program, "UserVec2");
3780                 p->loc_UserVec3                   = qglGetUniformLocationARB(p->program, "UserVec3");
3781                 p->loc_UserVec4                   = qglGetUniformLocationARB(p->program, "UserVec4");
3782                 p->loc_ViewTintColor              = qglGetUniformLocationARB(p->program, "ViewTintColor");
3783                 p->loc_ViewToLight                = qglGetUniformLocationARB(p->program, "ViewToLight");
3784                 p->loc_ModelToLight               = qglGetUniformLocationARB(p->program, "ModelToLight");
3785                 p->loc_TexMatrix                  = qglGetUniformLocationARB(p->program, "TexMatrix");
3786                 p->loc_BackgroundTexMatrix        = qglGetUniformLocationARB(p->program, "BackgroundTexMatrix");
3787                 p->loc_ModelViewMatrix            = qglGetUniformLocationARB(p->program, "ModelViewMatrix");
3788                 p->loc_ModelViewProjectionMatrix  = qglGetUniformLocationARB(p->program, "ModelViewProjectionMatrix");
3789                 p->loc_PixelToScreenTexCoord      = qglGetUniformLocationARB(p->program, "PixelToScreenTexCoord");
3790                 p->loc_ModelToReflectCube         = qglGetUniformLocationARB(p->program, "ModelToReflectCube");
3791                 p->loc_ShadowMapMatrix            = qglGetUniformLocationARB(p->program, "ShadowMapMatrix");
3792                 // initialize the samplers to refer to the texture units we use
3793                 if (p->loc_Texture_First           >= 0) qglUniform1iARB(p->loc_Texture_First          , GL20TU_FIRST);
3794                 if (p->loc_Texture_Second          >= 0) qglUniform1iARB(p->loc_Texture_Second         , GL20TU_SECOND);
3795                 if (p->loc_Texture_GammaRamps      >= 0) qglUniform1iARB(p->loc_Texture_GammaRamps     , GL20TU_GAMMARAMPS);
3796                 if (p->loc_Texture_Normal          >= 0) qglUniform1iARB(p->loc_Texture_Normal         , GL20TU_NORMAL);
3797                 if (p->loc_Texture_Color           >= 0) qglUniform1iARB(p->loc_Texture_Color          , GL20TU_COLOR);
3798                 if (p->loc_Texture_Gloss           >= 0) qglUniform1iARB(p->loc_Texture_Gloss          , GL20TU_GLOSS);
3799                 if (p->loc_Texture_Glow            >= 0) qglUniform1iARB(p->loc_Texture_Glow           , GL20TU_GLOW);
3800                 if (p->loc_Texture_SecondaryNormal >= 0) qglUniform1iARB(p->loc_Texture_SecondaryNormal, GL20TU_SECONDARY_NORMAL);
3801                 if (p->loc_Texture_SecondaryColor  >= 0) qglUniform1iARB(p->loc_Texture_SecondaryColor , GL20TU_SECONDARY_COLOR);
3802                 if (p->loc_Texture_SecondaryGloss  >= 0) qglUniform1iARB(p->loc_Texture_SecondaryGloss , GL20TU_SECONDARY_GLOSS);
3803                 if (p->loc_Texture_SecondaryGlow   >= 0) qglUniform1iARB(p->loc_Texture_SecondaryGlow  , GL20TU_SECONDARY_GLOW);
3804                 if (p->loc_Texture_Pants           >= 0) qglUniform1iARB(p->loc_Texture_Pants          , GL20TU_PANTS);
3805                 if (p->loc_Texture_Shirt           >= 0) qglUniform1iARB(p->loc_Texture_Shirt          , GL20TU_SHIRT);
3806                 if (p->loc_Texture_FogHeightTexture>= 0) qglUniform1iARB(p->loc_Texture_FogHeightTexture, GL20TU_FOGHEIGHTTEXTURE);
3807                 if (p->loc_Texture_FogMask         >= 0) qglUniform1iARB(p->loc_Texture_FogMask        , GL20TU_FOGMASK);
3808                 if (p->loc_Texture_Lightmap        >= 0) qglUniform1iARB(p->loc_Texture_Lightmap       , GL20TU_LIGHTMAP);
3809                 if (p->loc_Texture_Deluxemap       >= 0) qglUniform1iARB(p->loc_Texture_Deluxemap      , GL20TU_DELUXEMAP);
3810                 if (p->loc_Texture_Attenuation     >= 0) qglUniform1iARB(p->loc_Texture_Attenuation    , GL20TU_ATTENUATION);
3811                 if (p->loc_Texture_Cube            >= 0) qglUniform1iARB(p->loc_Texture_Cube           , GL20TU_CUBE);
3812                 if (p->loc_Texture_Refraction      >= 0) qglUniform1iARB(p->loc_Texture_Refraction     , GL20TU_REFRACTION);
3813                 if (p->loc_Texture_Reflection      >= 0) qglUniform1iARB(p->loc_Texture_Reflection     , GL20TU_REFLECTION);
3814                 if (p->loc_Texture_ShadowMapRect   >= 0) qglUniform1iARB(p->loc_Texture_ShadowMapRect  , permutation & SHADERPERMUTATION_SHADOWMAPORTHO ? GL20TU_SHADOWMAPORTHORECT : GL20TU_SHADOWMAPRECT);
3815                 if (p->loc_Texture_ShadowMapCube   >= 0) qglUniform1iARB(p->loc_Texture_ShadowMapCube  , GL20TU_SHADOWMAPCUBE);
3816                 if (p->loc_Texture_ShadowMap2D     >= 0) qglUniform1iARB(p->loc_Texture_ShadowMap2D    , permutation & SHADERPERMUTATION_SHADOWMAPORTHO ? GL20TU_SHADOWMAPORTHO2D : GL20TU_SHADOWMAP2D);
3817                 if (p->loc_Texture_CubeProjection  >= 0) qglUniform1iARB(p->loc_Texture_CubeProjection , GL20TU_CUBEPROJECTION);
3818                 if (p->loc_Texture_ScreenDepth     >= 0) qglUniform1iARB(p->loc_Texture_ScreenDepth    , GL20TU_SCREENDEPTH);
3819                 if (p->loc_Texture_ScreenNormalMap >= 0) qglUniform1iARB(p->loc_Texture_ScreenNormalMap, GL20TU_SCREENNORMALMAP);
3820                 if (p->loc_Texture_ScreenDiffuse   >= 0) qglUniform1iARB(p->loc_Texture_ScreenDiffuse  , GL20TU_SCREENDIFFUSE);
3821                 if (p->loc_Texture_ScreenSpecular  >= 0) qglUniform1iARB(p->loc_Texture_ScreenSpecular , GL20TU_SCREENSPECULAR);
3822                 if (p->loc_Texture_ReflectMask     >= 0) qglUniform1iARB(p->loc_Texture_ReflectMask    , GL20TU_REFLECTMASK);
3823                 if (p->loc_Texture_ReflectCube     >= 0) qglUniform1iARB(p->loc_Texture_ReflectCube    , GL20TU_REFLECTCUBE);
3824                 CHECKGLERROR
3825                 Con_DPrintf("^5GLSL shader %s compiled.\n", permutationname);
3826         }
3827         else
3828                 Con_Printf("^1GLSL shader %s failed!  some features may not work properly.\n", permutationname);
3829
3830         // free the strings
3831         if (vertexstring)
3832                 Mem_Free(vertexstring);
3833         if (geometrystring)
3834                 Mem_Free(geometrystring);
3835         if (fragmentstring)
3836                 Mem_Free(fragmentstring);
3837 }
3838
3839 void R_SetupShader_SetPermutationGLSL(unsigned int mode, unsigned int permutation)
3840 {
3841         r_glsl_permutation_t *perm = R_GLSL_FindPermutation(mode, permutation);
3842         if (r_glsl_permutation != perm)
3843         {
3844                 r_glsl_permutation = perm;
3845                 if (!r_glsl_permutation->program)
3846                 {
3847                         if (!r_glsl_permutation->compiled)
3848                                 R_GLSL_CompilePermutation(perm, mode, permutation);
3849                         if (!r_glsl_permutation->program)
3850                         {
3851                                 // remove features until we find a valid permutation
3852                                 int i;
3853                                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
3854                                 {
3855                                         // reduce i more quickly whenever it would not remove any bits
3856                                         int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
3857                                         if (!(permutation & j))
3858                                                 continue;
3859                                         permutation -= j;
3860                                         r_glsl_permutation = R_GLSL_FindPermutation(mode, permutation);
3861                                         if (!r_glsl_permutation->compiled)
3862                                                 R_GLSL_CompilePermutation(perm, mode, permutation);
3863                                         if (r_glsl_permutation->program)
3864                                                 break;
3865                                 }
3866                                 if (i >= SHADERPERMUTATION_COUNT)
3867                                 {
3868                                         //Con_Printf("Could not find a working OpenGL 2.0 shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext);
3869                                         r_glsl_permutation = R_GLSL_FindPermutation(mode, permutation);
3870                                         qglUseProgramObjectARB(0);CHECKGLERROR
3871                                         return; // no bit left to clear, entire mode is broken
3872                                 }
3873                         }
3874                 }
3875                 CHECKGLERROR
3876                 qglUseProgramObjectARB(r_glsl_permutation->program);CHECKGLERROR
3877         }
3878         if (r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f);
3879         if (r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f);
3880         if (r_glsl_permutation->loc_ClientTime >= 0) qglUniform1fARB(r_glsl_permutation->loc_ClientTime, cl.time);
3881 }
3882
3883 #ifdef SUPPORTCG
3884 #include <Cg/cgGL.h>
3885 struct r_cg_permutation_s;
3886 typedef struct r_cg_permutation_s
3887 {
3888         /// hash lookup data
3889         struct r_cg_permutation_s *hashnext;
3890         unsigned int mode;
3891         unsigned int permutation;
3892
3893         /// indicates if we have tried compiling this permutation already
3894         qboolean compiled;
3895         /// 0 if compilation failed
3896         CGprogram vprogram;
3897         CGprogram fprogram;
3898         /// locations of detected parameters in programs, or NULL if not found
3899         CGparameter vp_EyePosition;
3900         CGparameter vp_FogPlane;
3901         CGparameter vp_LightDir;
3902         CGparameter vp_LightPosition;
3903         CGparameter vp_ModelToLight;
3904         CGparameter vp_TexMatrix;
3905         CGparameter vp_BackgroundTexMatrix;
3906         CGparameter vp_ModelViewProjectionMatrix;
3907         CGparameter vp_ModelViewMatrix;
3908         CGparameter vp_ShadowMapMatrix;
3909
3910         CGparameter fp_Texture_First;
3911         CGparameter fp_Texture_Second;
3912         CGparameter fp_Texture_GammaRamps;
3913         CGparameter fp_Texture_Normal;
3914         CGparameter fp_Texture_Color;
3915         CGparameter fp_Texture_Gloss;
3916         CGparameter fp_Texture_Glow;
3917         CGparameter fp_Texture_SecondaryNormal;
3918         CGparameter fp_Texture_SecondaryColor;
3919         CGparameter fp_Texture_SecondaryGloss;
3920         CGparameter fp_Texture_SecondaryGlow;
3921         CGparameter fp_Texture_Pants;
3922         CGparameter fp_Texture_Shirt;
3923         CGparameter fp_Texture_FogHeightTexture;
3924         CGparameter fp_Texture_FogMask;
3925         CGparameter fp_Texture_Lightmap;
3926         CGparameter fp_Texture_Deluxemap;
3927         CGparameter fp_Texture_Attenuation;
3928         CGparameter fp_Texture_Cube;
3929         CGparameter fp_Texture_Refraction;
3930         CGparameter fp_Texture_Reflection;
3931         CGparameter fp_Texture_ShadowMapRect;
3932         CGparameter fp_Texture_ShadowMapCube;
3933         CGparameter fp_Texture_ShadowMap2D;
3934         CGparameter fp_Texture_CubeProjection;
3935         CGparameter fp_Texture_ScreenDepth;
3936         CGparameter fp_Texture_ScreenNormalMap;
3937         CGparameter fp_Texture_ScreenDiffuse;
3938         CGparameter fp_Texture_ScreenSpecular;
3939         CGparameter fp_Texture_ReflectMask;
3940         CGparameter fp_Texture_ReflectCube;
3941         CGparameter fp_Alpha;
3942         CGparameter fp_BloomBlur_Parameters;
3943         CGparameter fp_ClientTime;
3944         CGparameter fp_Color_Ambient;
3945         CGparameter fp_Color_Diffuse;
3946         CGparameter fp_Color_Specular;
3947         CGparameter fp_Color_Glow;
3948         CGparameter fp_Color_Pants;
3949         CGparameter fp_Color_Shirt;
3950         CGparameter fp_DeferredColor_Ambient;
3951         CGparameter fp_DeferredColor_Diffuse;
3952         CGparameter fp_DeferredColor_Specular;
3953         CGparameter fp_DeferredMod_Diffuse;
3954         CGparameter fp_DeferredMod_Specular;
3955         CGparameter fp_DistortScaleRefractReflect;
3956         CGparameter fp_EyePosition;
3957         CGparameter fp_FogColor;
3958         CGparameter fp_FogHeightFade;
3959         CGparameter fp_FogPlane;
3960         CGparameter fp_FogPlaneViewDist;
3961         CGparameter fp_FogRangeRecip;
3962         CGparameter fp_LightColor;
3963         CGparameter fp_LightDir;
3964         CGparameter fp_LightPosition;
3965         CGparameter fp_OffsetMapping_Scale;
3966         CGparameter fp_PixelSize;
3967         CGparameter fp_ReflectColor;
3968         CGparameter fp_ReflectFactor;
3969         CGparameter fp_ReflectOffset;
3970         CGparameter fp_RefractColor;
3971         CGparameter fp_Saturation;
3972         CGparameter fp_ScreenCenterRefractReflect;
3973         CGparameter fp_ScreenScaleRefractReflect;
3974         CGparameter fp_ScreenToDepth;
3975         CGparameter fp_ShadowMap_Parameters;
3976         CGparameter fp_ShadowMap_TextureScale;
3977         CGparameter fp_SpecularPower;
3978         CGparameter fp_UserVec1;
3979         CGparameter fp_UserVec2;
3980         CGparameter fp_UserVec3;
3981         CGparameter fp_UserVec4;
3982         CGparameter fp_ViewTintColor;
3983         CGparameter fp_ViewToLight;
3984         CGparameter fp_PixelToScreenTexCoord;
3985         CGparameter fp_ModelToReflectCube;
3986 }
3987 r_cg_permutation_t;
3988
3989 /// information about each possible shader permutation
3990 r_cg_permutation_t *r_cg_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
3991 /// currently selected permutation
3992 r_cg_permutation_t *r_cg_permutation;
3993 /// storage for permutations linked in the hash table
3994 memexpandablearray_t r_cg_permutationarray;
3995
3996 #define CHECKCGERROR {CGerror err = cgGetError(), err2 = err;if (err){Con_Printf("%s:%i CG error %i: %s : %s\n", __FILE__, __LINE__, err, cgGetErrorString(err), cgGetLastErrorString(&err2));if (err == 1) Con_Printf("last listing:\n%s\n", cgGetLastListing(vid.cgcontext));}}
3997
3998 static r_cg_permutation_t *R_CG_FindPermutation(unsigned int mode, unsigned int permutation)
3999 {
4000         //unsigned int hashdepth = 0;
4001         unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
4002         r_cg_permutation_t *p;
4003         for (p = r_cg_permutationhash[mode][hashindex];p;p = p->hashnext)
4004         {
4005                 if (p->mode == mode && p->permutation == permutation)
4006                 {
4007                         //if (hashdepth > 10)
4008                         //      Con_Printf("R_CG_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
4009                         return p;
4010                 }
4011                 //hashdepth++;
4012         }
4013         p = (r_cg_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_cg_permutationarray);
4014         p->mode = mode;
4015         p->permutation = permutation;
4016         p->hashnext = r_cg_permutationhash[mode][hashindex];
4017         r_cg_permutationhash[mode][hashindex] = p;
4018         //if (hashdepth > 10)
4019         //      Con_Printf("R_CG_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
4020         return p;
4021 }
4022
4023 static char *R_CG_GetText(const char *filename, qboolean printfromdisknotice)
4024 {
4025         char *shaderstring;
4026         if (!filename || !filename[0])
4027                 return NULL;
4028         if (!strcmp(filename, "cg/default.cg"))
4029         {
4030                 if (!cgshaderstring)
4031                 {
4032                         cgshaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
4033                         if (cgshaderstring)
4034                                 Con_DPrintf("Loading shaders from file %s...\n", filename);
4035                         else
4036                                 cgshaderstring = (char *)builtincgshaderstring;
4037                 }
4038                 shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(cgshaderstring) + 1);
4039                 memcpy(shaderstring, cgshaderstring, strlen(cgshaderstring) + 1);
4040                 return shaderstring;
4041         }
4042         shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
4043         if (shaderstring)
4044         {
4045                 if (printfromdisknotice)
4046                         Con_DPrintf("from disk %s... ", filename);
4047                 return shaderstring;
4048         }
4049         return shaderstring;
4050 }
4051
4052 static void R_CG_CacheShader(r_cg_permutation_t *p, const char *cachename, const char *vertstring, const char *fragstring)
4053 {
4054         // TODO: load or create .fp and .vp shader files
4055 }
4056
4057 static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, unsigned int permutation)
4058 {
4059         int i;
4060         shadermodeinfo_t *modeinfo = cgshadermodeinfo + mode;
4061         int vertstrings_count = 0, vertstring_length = 0;
4062         int geomstrings_count = 0, geomstring_length = 0;
4063         int fragstrings_count = 0, fragstring_length = 0;
4064         char *t;
4065         char *vertexstring, *geometrystring, *fragmentstring;
4066         char *vertstring, *geomstring, *fragstring;
4067         const char *vertstrings_list[32+3];
4068         const char *geomstrings_list[32+3];
4069         const char *fragstrings_list[32+3];
4070         char permutationname[256];
4071         char cachename[256];
4072         CGprofile vertexProfile;
4073         CGprofile fragmentProfile;
4074
4075         if (p->compiled)
4076                 return;
4077         p->compiled = true;
4078         p->vprogram = NULL;
4079         p->fprogram = NULL;
4080
4081         permutationname[0] = 0;
4082         cachename[0] = 0;
4083         vertexstring   = R_CG_GetText(modeinfo->vertexfilename, true);
4084         geometrystring = R_CG_GetText(modeinfo->geometryfilename, false);
4085         fragmentstring = R_CG_GetText(modeinfo->fragmentfilename, false);
4086
4087         strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname));
4088         strlcat(cachename, "cg/", sizeof(cachename));
4089
4090         // the first pretext is which type of shader to compile as
4091         // (later these will all be bound together as a program object)
4092         vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
4093         geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
4094         fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
4095
4096         // the second pretext is the mode (for example a light source)
4097         vertstrings_list[vertstrings_count++] = modeinfo->pretext;
4098         geomstrings_list[geomstrings_count++] = modeinfo->pretext;
4099         fragstrings_list[fragstrings_count++] = modeinfo->pretext;
4100         strlcat(permutationname, modeinfo->name, sizeof(permutationname));
4101         strlcat(cachename, modeinfo->name, sizeof(cachename));
4102
4103         // now add all the permutation pretexts
4104         for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
4105         {
4106                 if (permutation & (1<<i))
4107                 {
4108                         vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
4109                         geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
4110                         fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
4111                         strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
4112                         strlcat(cachename, shaderpermutationinfo[i].name, sizeof(cachename));
4113                 }
4114                 else
4115                 {
4116                         // keep line numbers correct
4117                         vertstrings_list[vertstrings_count++] = "\n";
4118                         geomstrings_list[geomstrings_count++] = "\n";
4119                         fragstrings_list[fragstrings_count++] = "\n";
4120                 }
4121         }
4122
4123         // replace spaces in the cachename with _ characters
4124         for (i = 0;cachename[i];i++)
4125                 if (cachename[i] == ' ')
4126                         cachename[i] = '_';
4127
4128         // now append the shader text itself
4129         vertstrings_list[vertstrings_count++] = vertexstring;
4130         geomstrings_list[geomstrings_count++] = geometrystring;
4131         fragstrings_list[fragstrings_count++] = fragmentstring;
4132
4133         // if any sources were NULL, clear the respective list
4134         if (!vertexstring)
4135                 vertstrings_count = 0;
4136         if (!geometrystring)
4137                 geomstrings_count = 0;
4138         if (!fragmentstring)
4139                 fragstrings_count = 0;
4140
4141         vertstring_length = 0;
4142         for (i = 0;i < vertstrings_count;i++)
4143                 vertstring_length += strlen(vertstrings_list[i]);
4144         vertstring = t = Mem_Alloc(tempmempool, vertstring_length + 1);
4145         for (i = 0;i < vertstrings_count;t += strlen(vertstrings_list[i]), i++)
4146                 memcpy(t, vertstrings_list[i], strlen(vertstrings_list[i]));
4147
4148         geomstring_length = 0;
4149         for (i = 0;i < geomstrings_count;i++)
4150                 geomstring_length += strlen(geomstrings_list[i]);
4151         geomstring = t = Mem_Alloc(tempmempool, geomstring_length + 1);
4152         for (i = 0;i < geomstrings_count;t += strlen(geomstrings_list[i]), i++)
4153                 memcpy(t, geomstrings_list[i], strlen(geomstrings_list[i]));
4154
4155         fragstring_length = 0;
4156         for (i = 0;i < fragstrings_count;i++)
4157                 fragstring_length += strlen(fragstrings_list[i]);
4158         fragstring = t = Mem_Alloc(tempmempool, fragstring_length + 1);
4159         for (i = 0;i < fragstrings_count;t += strlen(fragstrings_list[i]), i++)
4160                 memcpy(t, fragstrings_list[i], strlen(fragstrings_list[i]));
4161
4162         CHECKGLERROR
4163         CHECKCGERROR
4164         //vertexProfile = CG_PROFILE_ARBVP1;
4165         //fragmentProfile = CG_PROFILE_ARBFP1;
4166         vertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);CHECKCGERROR
4167         fragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);CHECKCGERROR
4168         //cgGLSetOptimalOptions(vertexProfile);CHECKCGERROR
4169         //cgGLSetOptimalOptions(fragmentProfile);CHECKCGERROR
4170         //cgSetAutoCompile(vid.cgcontext, CG_COMPILE_MANUAL);CHECKCGERROR
4171         CHECKGLERROR
4172
4173         // try to load the cached shader, or generate one
4174         R_CG_CacheShader(p, cachename, vertstring, fragstring);
4175
4176         // if caching failed, do a dynamic compile for now
4177         CHECKCGERROR
4178         if (vertstring[0] && !p->vprogram)
4179                 p->vprogram = cgCreateProgram(vid.cgcontext, CG_SOURCE, vertstring, vertexProfile, NULL, NULL);
4180         CHECKCGERROR
4181         if (fragstring[0] && !p->fprogram)
4182                 p->fprogram = cgCreateProgram(vid.cgcontext, CG_SOURCE, fragstring, fragmentProfile, NULL, NULL);
4183         CHECKCGERROR
4184
4185         // look up all the uniform variable names we care about, so we don't
4186         // have to look them up every time we set them
4187         if (p->vprogram)
4188         {
4189                 CHECKCGERROR
4190                 cgGLLoadProgram(p->vprogram);CHECKCGERROR CHECKGLERROR
4191                 cgGLEnableProfile(vertexProfile);CHECKCGERROR CHECKGLERROR
4192                 p->vp_EyePosition                = cgGetNamedParameter(p->vprogram, "EyePosition");
4193                 p->vp_FogPlane                   = cgGetNamedParameter(p->vprogram, "FogPlane");
4194                 p->vp_LightDir                   = cgGetNamedParameter(p->vprogram, "LightDir");
4195                 p->vp_LightPosition              = cgGetNamedParameter(p->vprogram, "LightPosition");
4196                 p->vp_ModelToLight               = cgGetNamedParameter(p->vprogram, "ModelToLight");
4197                 p->vp_TexMatrix                  = cgGetNamedParameter(p->vprogram, "TexMatrix");
4198                 p->vp_BackgroundTexMatrix        = cgGetNamedParameter(p->vprogram, "BackgroundTexMatrix");
4199                 p->vp_ModelViewProjectionMatrix  = cgGetNamedParameter(p->vprogram, "ModelViewProjectionMatrix");
4200                 p->vp_ModelViewMatrix            = cgGetNamedParameter(p->vprogram, "ModelViewMatrix");
4201                 p->vp_ShadowMapMatrix            = cgGetNamedParameter(p->vprogram, "ShadowMapMatrix");
4202                 CHECKCGERROR
4203         }
4204         if (p->fprogram)
4205         {
4206                 CHECKCGERROR
4207                 cgGLLoadProgram(p->fprogram);CHECKCGERROR CHECKGLERROR
4208                 cgGLEnableProfile(fragmentProfile);CHECKCGERROR CHECKGLERROR
4209                 p->fp_Texture_First              = cgGetNamedParameter(p->fprogram, "Texture_First");
4210                 p->fp_Texture_Second             = cgGetNamedParameter(p->fprogram, "Texture_Second");
4211                 p->fp_Texture_GammaRamps         = cgGetNamedParameter(p->fprogram, "Texture_GammaRamps");
4212                 p->fp_Texture_Normal             = cgGetNamedParameter(p->fprogram, "Texture_Normal");
4213                 p->fp_Texture_Color              = cgGetNamedParameter(p->fprogram, "Texture_Color");
4214                 p->fp_Texture_Gloss              = cgGetNamedParameter(p->fprogram, "Texture_Gloss");
4215                 p->fp_Texture_Glow               = cgGetNamedParameter(p->fprogram, "Texture_Glow");
4216                 p->fp_Texture_SecondaryNormal    = cgGetNamedParameter(p->fprogram, "Texture_SecondaryNormal");
4217                 p->fp_Texture_SecondaryColor     = cgGetNamedParameter(p->fprogram, "Texture_SecondaryColor");
4218                 p->fp_Texture_SecondaryGloss     = cgGetNamedParameter(p->fprogram, "Texture_SecondaryGloss");
4219                 p->fp_Texture_SecondaryGlow      = cgGetNamedParameter(p->fprogram, "Texture_SecondaryGlow");
4220                 p->fp_Texture_Pants              = cgGetNamedParameter(p->fprogram, "Texture_Pants");
4221                 p->fp_Texture_Shirt              = cgGetNamedParameter(p->fprogram, "Texture_Shirt");
4222                 p->fp_Texture_FogHeightTexture   = cgGetNamedParameter(p->fprogram, "Texture_FogHeightTexture");
4223                 p->fp_Texture_FogMask            = cgGetNamedParameter(p->fprogram, "Texture_FogMask");
4224                 p->fp_Texture_Lightmap           = cgGetNamedParameter(p->fprogram, "Texture_Lightmap");
4225                 p->fp_Texture_Deluxemap          = cgGetNamedParameter(p->fprogram, "Texture_Deluxemap");
4226                 p->fp_Texture_Attenuation        = cgGetNamedParameter(p->fprogram, "Texture_Attenuation");
4227                 p->fp_Texture_Cube               = cgGetNamedParameter(p->fprogram, "Texture_Cube");
4228                 p->fp_Texture_Refraction         = cgGetNamedParameter(p->fprogram, "Texture_Refraction");
4229                 p->fp_Texture_Reflection         = cgGetNamedParameter(p->fprogram, "Texture_Reflection");
4230                 p->fp_Texture_ShadowMapRect      = cgGetNamedParameter(p->fprogram, "Texture_ShadowMapRect");
4231                 p->fp_Texture_ShadowMapCube      = cgGetNamedParameter(p->fprogram, "Texture_ShadowMapCube");
4232                 p->fp_Texture_ShadowMap2D        = cgGetNamedParameter(p->fprogram, "Texture_ShadowMap2D");
4233                 p->fp_Texture_CubeProjection     = cgGetNamedParameter(p->fprogram, "Texture_CubeProjection");
4234                 p->fp_Texture_ScreenDepth        = cgGetNamedParameter(p->fprogram, "Texture_ScreenDepth");
4235                 p->fp_Texture_ScreenNormalMap    = cgGetNamedParameter(p->fprogram, "Texture_ScreenNormalMap");
4236                 p->fp_Texture_ScreenDiffuse      = cgGetNamedParameter(p->fprogram, "Texture_ScreenDiffuse");
4237                 p->fp_Texture_ScreenSpecular     = cgGetNamedParameter(p->fprogram, "Texture_ScreenSpecular");
4238                 p->fp_Texture_ReflectMask        = cgGetNamedParameter(p->fprogram, "Texture_ReflectMask");
4239                 p->fp_Texture_ReflectCube        = cgGetNamedParameter(p->fprogram, "Texture_ReflectCube");
4240                 p->fp_Alpha                      = cgGetNamedParameter(p->fprogram, "Alpha");
4241                 p->fp_BloomBlur_Parameters       = cgGetNamedParameter(p->fprogram, "BloomBlur_Parameters");
4242                 p->fp_ClientTime                 = cgGetNamedParameter(p->fprogram, "ClientTime");
4243                 p->fp_Color_Ambient              = cgGetNamedParameter(p->fprogram, "Color_Ambient");
4244                 p->fp_Color_Diffuse              = cgGetNamedParameter(p->fprogram, "Color_Diffuse");
4245                 p->fp_Color_Specular             = cgGetNamedParameter(p->fprogram, "Color_Specular");
4246                 p->fp_Color_Glow                 = cgGetNamedParameter(p->fprogram, "Color_Glow");
4247                 p->fp_Color_Pants                = cgGetNamedParameter(p->fprogram, "Color_Pants");
4248                 p->fp_Color_Shirt                = cgGetNamedParameter(p->fprogram, "Color_Shirt");
4249                 p->fp_DeferredColor_Ambient      = cgGetNamedParameter(p->fprogram, "DeferredColor_Ambient");
4250                 p->fp_DeferredColor_Diffuse      = cgGetNamedParameter(p->fprogram, "DeferredColor_Diffuse");
4251                 p->fp_DeferredColor_Specular     = cgGetNamedParameter(p->fprogram, "DeferredColor_Specular");
4252                 p->fp_DeferredMod_Diffuse        = cgGetNamedParameter(p->fprogram, "DeferredMod_Diffuse");
4253                 p->fp_DeferredMod_Specular       = cgGetNamedParameter(p->fprogram, "DeferredMod_Specular");
4254                 p->fp_DistortScaleRefractReflect = cgGetNamedParameter(p->fprogram, "DistortScaleRefractReflect");
4255                 p->fp_EyePosition                = cgGetNamedParameter(p->fprogram, "EyePosition");
4256                 p->fp_FogColor                   = cgGetNamedParameter(p->fprogram, "FogColor");
4257                 p->fp_FogHeightFade              = cgGetNamedParameter(p->fprogram, "FogHeightFade");
4258                 p->fp_FogPlane                   = cgGetNamedParameter(p->fprogram, "FogPlane");
4259                 p->fp_FogPlaneViewDist           = cgGetNamedParameter(p->fprogram, "FogPlaneViewDist");
4260                 p->fp_FogRangeRecip              = cgGetNamedParameter(p->fprogram, "FogRangeRecip");
4261                 p->fp_LightColor                 = cgGetNamedParameter(p->fprogram, "LightColor");
4262                 p->fp_LightDir                   = cgGetNamedParameter(p->fprogram, "LightDir");
4263                 p->fp_LightPosition              = cgGetNamedParameter(p->fprogram, "LightPosition");
4264                 p->fp_OffsetMapping_Scale        = cgGetNamedParameter(p->fprogram, "OffsetMapping_Scale");
4265                 p->fp_PixelSize                  = cgGetNamedParameter(p->fprogram, "PixelSize");
4266                 p->fp_ReflectColor               = cgGetNamedParameter(p->fprogram, "ReflectColor");
4267                 p->fp_ReflectFactor              = cgGetNamedParameter(p->fprogram, "ReflectFactor");
4268                 p->fp_ReflectOffset              = cgGetNamedParameter(p->fprogram, "ReflectOffset");
4269                 p->fp_RefractColor               = cgGetNamedParameter(p->fprogram, "RefractColor");
4270                 p->fp_Saturation                 = cgGetNamedParameter(p->fprogram, "Saturation");
4271                 p->fp_ScreenCenterRefractReflect = cgGetNamedParameter(p->fprogram, "ScreenCenterRefractReflect");
4272                 p->fp_ScreenScaleRefractReflect  = cgGetNamedParameter(p->fprogram, "ScreenScaleRefractReflect");
4273                 p->fp_ScreenToDepth              = cgGetNamedParameter(p->fprogram, "ScreenToDepth");
4274                 p->fp_ShadowMap_Parameters       = cgGetNamedParameter(p->fprogram, "ShadowMap_Parameters");
4275                 p->fp_ShadowMap_TextureScale     = cgGetNamedParameter(p->fprogram, "ShadowMap_TextureScale");
4276                 p->fp_SpecularPower              = cgGetNamedParameter(p->fprogram, "SpecularPower");
4277                 p->fp_UserVec1                   = cgGetNamedParameter(p->fprogram, "UserVec1");
4278                 p->fp_UserVec2                   = cgGetNamedParameter(p->fprogram, "UserVec2");
4279                 p->fp_UserVec3                   = cgGetNamedParameter(p->fprogram, "UserVec3");
4280                 p->fp_UserVec4                   = cgGetNamedParameter(p->fprogram, "UserVec4");
4281                 p->fp_ViewTintColor              = cgGetNamedParameter(p->fprogram, "ViewTintColor");
4282                 p->fp_ViewToLight                = cgGetNamedParameter(p->fprogram, "ViewToLight");
4283                 p->fp_PixelToScreenTexCoord      = cgGetNamedParameter(p->fprogram, "PixelToScreenTexCoord");
4284                 p->fp_ModelToReflectCube         = cgGetNamedParameter(p->fprogram, "ModelToReflectCube");
4285                 CHECKCGERROR
4286         }
4287
4288         if ((p->vprogram || !vertstring[0]) && (p->fprogram || !fragstring[0]))
4289                 Con_DPrintf("^5CG shader %s compiled.\n", permutationname);
4290         else
4291                 Con_Printf("^1CG shader %s failed!  some features may not work properly.\n", permutationname);
4292
4293         // free the strings
4294         if (vertstring)
4295                 Mem_Free(vertstring);
4296         if (geomstring)
4297                 Mem_Free(geomstring);
4298         if (fragstring)
4299                 Mem_Free(fragstring);
4300         if (vertexstring)
4301                 Mem_Free(vertexstring);
4302         if (geometrystring)
4303                 Mem_Free(geometrystring);
4304         if (fragmentstring)
4305                 Mem_Free(fragmentstring);
4306 }
4307
4308 void R_SetupShader_SetPermutationCG(unsigned int mode, unsigned int permutation)
4309 {
4310         r_cg_permutation_t *perm = R_CG_FindPermutation(mode, permutation);
4311         CHECKGLERROR
4312         CHECKCGERROR
4313         if (r_cg_permutation != perm)
4314         {
4315                 r_cg_permutation = perm;
4316                 if (!r_cg_permutation->vprogram && !r_cg_permutation->fprogram)
4317                 {
4318                         if (!r_cg_permutation->compiled)
4319                                 R_CG_CompilePermutation(perm, mode, permutation);
4320                         if (!r_cg_permutation->vprogram && !r_cg_permutation->fprogram)
4321                         {
4322                                 // remove features until we find a valid permutation
4323                                 int i;
4324                                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
4325                                 {
4326                                         // reduce i more quickly whenever it would not remove any bits
4327                                         int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
4328                                         if (!(permutation & j))
4329                                                 continue;
4330                                         permutation -= j;
4331                                         r_cg_permutation = R_CG_FindPermutation(mode, permutation);
4332                                         if (!r_cg_permutation->compiled)
4333                                                 R_CG_CompilePermutation(perm, mode, permutation);
4334                                         if (r_cg_permutation->vprogram || r_cg_permutation->fprogram)
4335                                                 break;
4336                                 }
4337                                 if (i >= SHADERPERMUTATION_COUNT)
4338                                 {
4339                                         //Con_Printf("Could not find a working Cg shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext);
4340                                         r_cg_permutation = R_CG_FindPermutation(mode, permutation);
4341                                         return; // no bit left to clear, entire mode is broken
4342                                 }
4343                         }
4344                 }
4345                 CHECKGLERROR
4346                 CHECKCGERROR
4347                 if (r_cg_permutation->vprogram)
4348                 {
4349                         cgGLLoadProgram(r_cg_permutation->vprogram);CHECKCGERROR CHECKGLERROR
4350                         cgGLBindProgram(r_cg_permutation->vprogram);CHECKCGERROR CHECKGLERROR
4351                         cgGLEnableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4352                 }
4353                 else
4354                 {
4355                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4356                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4357                 }
4358                 if (r_cg_permutation->fprogram)
4359                 {
4360                         cgGLLoadProgram(r_cg_permutation->fprogram);CHECKCGERROR CHECKGLERROR
4361                         cgGLBindProgram(r_cg_permutation->fprogram);CHECKCGERROR CHECKGLERROR
4362                         cgGLEnableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4363                 }
4364                 else
4365                 {
4366                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4367                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4368                 }
4369         }
4370         CHECKCGERROR
4371         if (r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR
4372         if (r_cg_permutation->vp_ModelViewMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelview16f);CHECKCGERROR
4373         if (r_cg_permutation->fp_ClientTime) cgGLSetParameter1f(r_cg_permutation->fp_ClientTime, cl.time);CHECKCGERROR
4374 }
4375
4376 void CG_BindTexture(CGparameter param, rtexture_t *tex)
4377 {
4378         cgGLSetTextureParameter(param, R_GetTexture(tex));
4379         cgGLEnableTextureParameter(param);
4380 }
4381 #endif
4382
4383 void R_GLSL_Restart_f(void)
4384 {
4385         unsigned int i, limit;
4386         if (glslshaderstring && glslshaderstring != builtinshaderstring)
4387                 Mem_Free(glslshaderstring);
4388         glslshaderstring = NULL;
4389         if (cgshaderstring && cgshaderstring != builtincgshaderstring)
4390                 Mem_Free(cgshaderstring);
4391         cgshaderstring = NULL;
4392         switch(vid.renderpath)
4393         {
4394         case RENDERPATH_GL20:
4395                 {
4396                         r_glsl_permutation_t *p;
4397                         r_glsl_permutation = NULL;
4398                         limit = Mem_ExpandableArray_IndexRange(&r_glsl_permutationarray);
4399                         for (i = 0;i < limit;i++)
4400                         {
4401                                 if ((p = (r_glsl_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_glsl_permutationarray, i)))
4402                                 {
4403                                         GL_Backend_FreeProgram(p->program);
4404                                         Mem_ExpandableArray_FreeRecord(&r_glsl_permutationarray, (void*)p);
4405                                 }
4406                         }
4407                         memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
4408                 }
4409                 break;
4410         case RENDERPATH_CGGL:
4411 #ifdef SUPPORTCG
4412                 {
4413                         r_cg_permutation_t *p;
4414                         r_cg_permutation = NULL;
4415                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4416                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4417                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4418                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4419                         limit = Mem_ExpandableArray_IndexRange(&r_cg_permutationarray);
4420                         for (i = 0;i < limit;i++)
4421                         {
4422                                 if ((p = (r_cg_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_cg_permutationarray, i)))
4423                                 {
4424                                         if (p->vprogram)
4425                                                 cgDestroyProgram(p->vprogram);
4426                                         if (p->fprogram)
4427                                                 cgDestroyProgram(p->fprogram);
4428                                         Mem_ExpandableArray_FreeRecord(&r_cg_permutationarray, (void*)p);
4429                                 }
4430                         }
4431                         memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash));
4432                 }
4433                 break;
4434 #endif
4435         case RENDERPATH_GL13:
4436         case RENDERPATH_GL11:
4437                 break;
4438         }
4439 }
4440
4441 void R_GLSL_DumpShader_f(void)
4442 {
4443         int i;
4444         qfile_t *file;
4445
4446         file = FS_OpenRealFile("glsl/default.glsl", "w", false);
4447         if (file)
4448         {
4449                 FS_Print(file, "/* The engine may define the following macros:\n");
4450                 FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
4451                 for (i = 0;i < SHADERMODE_COUNT;i++)
4452                         FS_Print(file, glslshadermodeinfo[i].pretext);
4453                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
4454                         FS_Print(file, shaderpermutationinfo[i].pretext);
4455                 FS_Print(file, "*/\n");
4456                 FS_Print(file, builtinshaderstring);
4457                 FS_Close(file);
4458                 Con_Printf("glsl/default.glsl written\n");
4459         }
4460         else
4461                 Con_Printf("failed to write to glsl/default.glsl\n");
4462
4463 #ifdef SUPPORTCG
4464         file = FS_OpenRealFile("cg/default.cg", "w", false);
4465         if (file)
4466         {
4467                 FS_Print(file, "/* The engine may define the following macros:\n");
4468                 FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
4469                 for (i = 0;i < SHADERMODE_COUNT;i++)
4470                         FS_Print(file, cgshadermodeinfo[i].pretext);
4471                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
4472                         FS_Print(file, shaderpermutationinfo[i].pretext);
4473                 FS_Print(file, "*/\n");
4474                 FS_Print(file, builtincgshaderstring);
4475                 FS_Close(file);
4476                 Con_Printf("cg/default.cg written\n");
4477         }
4478         else
4479                 Con_Printf("failed to write to cg/default.cg\n");
4480 #endif
4481 }
4482
4483 void R_SetupShader_Generic(rtexture_t *first, rtexture_t *second, int texturemode, int rgbscale)
4484 {
4485         if (!second)
4486                 texturemode = GL_MODULATE;
4487         switch (vid.renderpath)
4488         {
4489         case RENDERPATH_GL20:
4490                 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))));
4491                 if (r_glsl_permutation->loc_Texture_First ) R_Mesh_TexBind(GL20TU_FIRST , first );
4492                 if (r_glsl_permutation->loc_Texture_Second) R_Mesh_TexBind(GL20TU_SECOND, second);
4493                 break;
4494         case RENDERPATH_CGGL:
4495 #ifdef SUPPORTCG
4496                 CHECKCGERROR
4497                 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))));
4498                 if (r_cg_permutation->fp_Texture_First ) CG_BindTexture(r_cg_permutation->fp_Texture_First , first );CHECKCGERROR
4499                 if (r_cg_permutation->fp_Texture_Second) CG_BindTexture(r_cg_permutation->fp_Texture_Second, second);CHECKCGERROR
4500 #endif
4501                 break;
4502         case RENDERPATH_GL13:
4503                 R_Mesh_TexBind(0, first );
4504                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
4505                 R_Mesh_TexBind(1, second);
4506                 if (second)
4507                         R_Mesh_TexCombine(1, texturemode, texturemode, rgbscale, 1);
4508                 break;
4509         case RENDERPATH_GL11:
4510                 R_Mesh_TexBind(0, first );
4511                 break;
4512         }
4513 }
4514
4515 void R_SetupShader_DepthOrShadow(void)
4516 {
4517         switch (vid.renderpath)
4518         {
4519         case RENDERPATH_GL20:
4520                 R_SetupShader_SetPermutationGLSL(SHADERMODE_DEPTH_OR_SHADOW, 0);
4521                 break;
4522         case RENDERPATH_CGGL:
4523 #ifdef SUPPORTCG
4524                 R_SetupShader_SetPermutationCG(SHADERMODE_DEPTH_OR_SHADOW, 0);
4525 #endif
4526                 break;
4527         case RENDERPATH_GL13:
4528                 R_Mesh_TexBind(0, 0);
4529                 R_Mesh_TexBind(1, 0);
4530                 break;
4531         case RENDERPATH_GL11:
4532                 R_Mesh_TexBind(0, 0);
4533                 break;
4534         }
4535 }
4536
4537 void R_SetupShader_ShowDepth(void)
4538 {
4539         switch (vid.renderpath)
4540         {
4541         case RENDERPATH_GL20:
4542                 R_SetupShader_SetPermutationGLSL(SHADERMODE_SHOWDEPTH, 0);
4543                 break;
4544         case RENDERPATH_CGGL:
4545 #ifdef SUPPORTCG
4546                 R_SetupShader_SetPermutationCG(SHADERMODE_SHOWDEPTH, 0);
4547 #endif
4548                 break;
4549         case RENDERPATH_GL13:
4550                 break;
4551         case RENDERPATH_GL11:
4552                 break;
4553         }
4554 }
4555
4556 extern qboolean r_shadow_usingdeferredprepass;
4557 extern cvar_t r_shadow_deferred_8bitrange;
4558 extern rtexture_t *r_shadow_attenuationgradienttexture;
4559 extern rtexture_t *r_shadow_attenuation2dtexture;
4560 extern rtexture_t *r_shadow_attenuation3dtexture;
4561 extern qboolean r_shadow_usingshadowmaprect;
4562 extern qboolean r_shadow_usingshadowmapcube;
4563 extern qboolean r_shadow_usingshadowmap2d;
4564 extern qboolean r_shadow_usingshadowmaportho;
4565 extern float r_shadow_shadowmap_texturescale[2];
4566 extern float r_shadow_shadowmap_parameters[4];
4567 extern qboolean r_shadow_shadowmapvsdct;
4568 extern qboolean r_shadow_shadowmapsampler;
4569 extern int r_shadow_shadowmappcf;
4570 extern rtexture_t *r_shadow_shadowmaprectangletexture;
4571 extern rtexture_t *r_shadow_shadowmap2dtexture;
4572 extern rtexture_t *r_shadow_shadowmapcubetexture[R_SHADOW_SHADOWMAP_NUMCUBEMAPS];
4573 extern rtexture_t *r_shadow_shadowmapvsdcttexture;
4574 extern matrix4x4_t r_shadow_shadowmapmatrix;
4575 extern int r_shadow_shadowmaplod; // changes for each light based on distance
4576 extern int r_shadow_prepass_width;
4577 extern int r_shadow_prepass_height;
4578 extern rtexture_t *r_shadow_prepassgeometrydepthtexture;
4579 extern rtexture_t *r_shadow_prepassgeometrynormalmaptexture;
4580 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
4581 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
4582 static qboolean R_BlendFuncAllowsColormod(int src, int dst)
4583 {
4584         // a blendfunc allows colormod if:
4585         // a) it can never keep the destination pixel invariant, or
4586         // b) it can keep the destination pixel invariant, and still can do so if colormodded
4587         // this is to prevent unintended side effects from colormod
4588
4589         // in formulas:
4590         // IF there is a (s, sa) for which for all (d, da),
4591         //   s * src(s, d, sa, da) + d * dst(s, d, sa, da) == d
4592         // THEN, for this (s, sa) and all (colormod, d, da):
4593         //   s*colormod * src(s*colormod, d, sa, da) + d * dst(s*colormod, d, sa, da) == d
4594         // OBVIOUSLY, this means that
4595         //   s*colormod * src(s*colormod, d, sa, da) = 0
4596         //   dst(s*colormod, d, sa, da)              = 1
4597
4598         // note: not caring about GL_SRC_ALPHA_SATURATE and following here, these are unused in DP code
4599
4600         // main condition to leave dst color invariant:
4601         //   s * src(s, d, sa, da) + d * dst(s, d, sa, da) == d
4602         //   src == GL_ZERO:
4603         //     s * 0 + d * dst(s, d, sa, da) == d
4604         //       => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4605         //       => colormod is a problem for GL_SRC_COLOR only
4606         //   src == GL_ONE:
4607         //     s + d * dst(s, d, sa, da) == d
4608         //       => s == 0
4609         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4610         //       => colormod is never problematic for these
4611         //   src == GL_SRC_COLOR:
4612         //     s*s + d * dst(s, d, sa, da) == d
4613         //       => s == 0
4614         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4615         //       => colormod is never problematic for these
4616         //   src == GL_ONE_MINUS_SRC_COLOR:
4617         //     s*(1-s) + d * dst(s, d, sa, da) == d
4618         //       => s == 0 or s == 1
4619         //       => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4620         //       => colormod is a problem for GL_SRC_COLOR only
4621         //   src == GL_DST_COLOR
4622         //     s*d + d * dst(s, d, sa, da) == d
4623         //       => s == 1
4624         //       => dst == GL_ZERO/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4625         //       => colormod is always a problem
4626         //     or
4627         //       => s == 0
4628         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4629         //       => colormod is never problematic for these
4630         //       => BUT, we do not know s! We must assume it is problematic
4631         //       then... except in GL_ONE case, where we know all invariant
4632         //       cases are fine
4633         //   src == GL_ONE_MINUS_DST_COLOR
4634         //     s*(1-d) + d * dst(s, d, sa, da) == d
4635         //       => s == 0 (1-d is impossible to handle for our desired result)
4636         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4637         //       => colormod is never problematic for these
4638         //   src == GL_SRC_ALPHA
4639         //     s*sa + d * dst(s, d, sa, da) == d
4640         //       => s == 0, or sa == 0
4641         //       => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4642         //       => colormod breaks in the case GL_SRC_COLOR only
4643         //   src == GL_ONE_MINUS_SRC_ALPHA
4644         //     s*(1-sa) + d * dst(s, d, sa, da) == d
4645         //       => s == 0, or sa == 1
4646         //       => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4647         //       => colormod breaks in the case GL_SRC_COLOR only
4648         //   src == GL_DST_ALPHA
4649         //     s*da + d * dst(s, d, sa, da) == d
4650         //       => s == 0
4651         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4652         //       => colormod is never problematic for these
4653
4654         switch(src)
4655         {
4656                 case GL_ZERO:
4657                 case GL_ONE_MINUS_SRC_COLOR:
4658                 case GL_SRC_ALPHA:
4659                 case GL_ONE_MINUS_SRC_ALPHA:
4660                         if(dst == GL_SRC_COLOR)
4661                                 return false;
4662                         return true;
4663                 case GL_ONE:
4664                 case GL_SRC_COLOR:
4665                 case GL_ONE_MINUS_DST_COLOR:
4666                 case GL_DST_ALPHA:
4667                 case GL_ONE_MINUS_DST_ALPHA:
4668                         return true;
4669                 case GL_DST_COLOR:
4670                         if(dst == GL_ONE)
4671                                 return true;
4672                         return false;
4673                 default:
4674                         return false;
4675         }
4676 }
4677 void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass)
4678 {
4679         // select a permutation of the lighting shader appropriate to this
4680         // combination of texture, entity, light source, and fogging, only use the
4681         // minimum features necessary to avoid wasting rendering time in the
4682         // fragment shader on features that are not being used
4683         unsigned int permutation = 0;
4684         unsigned int mode = 0;
4685         qboolean allow_colormod;
4686         static float dummy_colormod[3] = {1, 1, 1};
4687         float *colormod = rsurface.colormod;
4688         float m16f[16];
4689         if (rsurfacepass == RSURFPASS_BACKGROUND)
4690         {
4691                 // distorted background
4692                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
4693                         mode = SHADERMODE_WATER;
4694                 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFRACTION)
4695                         mode = SHADERMODE_REFRACTION;
4696                 else
4697                 {
4698                         mode = SHADERMODE_GENERIC;
4699                         permutation |= SHADERPERMUTATION_DIFFUSE;
4700                 }
4701                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
4702                 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
4703                 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
4704                 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
4705                 R_Mesh_TexCoordPointer(4, 0, NULL, 0, 0);
4706                 R_Mesh_ColorPointer(NULL, 0, 0);
4707                 GL_AlphaTest(false);
4708                 GL_BlendFunc(GL_ONE, GL_ZERO);
4709                 allow_colormod = R_BlendFuncAllowsColormod(GL_ONE, GL_ZERO);
4710         }
4711         else if (rsurfacepass == RSURFPASS_DEFERREDGEOMETRY)
4712         {
4713                 if (r_glsl_offsetmapping.integer)
4714                 {
4715                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
4716                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4717                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
4718                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4719                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
4720                         {
4721                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4722                                 if (r_glsl_offsetmapping_reliefmapping.integer)
4723                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4724                         }
4725                 }
4726                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
4727                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
4728                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
4729                         permutation |= SHADERPERMUTATION_ALPHAKILL;
4730                 // normalmap (deferred prepass), may use alpha test on diffuse
4731                 mode = SHADERMODE_DEFERREDGEOMETRY;
4732                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
4733                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
4734                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
4735                 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
4736                 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
4737                 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
4738                 R_Mesh_TexCoordPointer(4, 0, NULL, 0, 0);
4739                 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND)
4740                         R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
4741                 else
4742                         R_Mesh_ColorPointer(NULL, 0, 0);
4743                 GL_AlphaTest(false);
4744                 GL_BlendFunc(GL_ONE, GL_ZERO);
4745                 allow_colormod = R_BlendFuncAllowsColormod(GL_ONE, GL_ZERO);
4746         }
4747         else if (rsurfacepass == RSURFPASS_RTLIGHT)
4748         {
4749                 if (r_glsl_offsetmapping.integer)
4750                 {
4751                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
4752                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4753                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
4754                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4755                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
4756                         {
4757                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4758                                 if (r_glsl_offsetmapping_reliefmapping.integer)
4759                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4760                         }
4761                 }
4762                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
4763                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
4764                 // light source
4765                 mode = SHADERMODE_LIGHTSOURCE;
4766                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
4767                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
4768                 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
4769                         permutation |= SHADERPERMUTATION_CUBEFILTER;
4770                 if (diffusescale > 0)
4771                         permutation |= SHADERPERMUTATION_DIFFUSE;
4772                 if (specularscale > 0)
4773                 {
4774                         permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
4775                         if (r_shadow_glossexact.integer)
4776                                 permutation |= SHADERPERMUTATION_EXACTSPECULARMATH;
4777                 }
4778                 if (r_refdef.fogenabled)
4779                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
4780                 if (rsurface.texture->colormapping)
4781                         permutation |= SHADERPERMUTATION_COLORMAPPING;
4782                 if (r_shadow_usingshadowmaprect || r_shadow_usingshadowmap2d || r_shadow_usingshadowmapcube)
4783                 {
4784                         if (r_shadow_usingshadowmaprect)
4785                                 permutation |= SHADERPERMUTATION_SHADOWMAPRECT;
4786                         if (r_shadow_usingshadowmap2d)
4787                                 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
4788                         if (r_shadow_usingshadowmapcube)
4789                                 permutation |= SHADERPERMUTATION_SHADOWMAPCUBE;
4790                         else if(r_shadow_shadowmapvsdct)
4791                                 permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT;
4792
4793                         if (r_shadow_shadowmapsampler)
4794                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
4795                         if (r_shadow_shadowmappcf > 1)
4796                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
4797                         else if (r_shadow_shadowmappcf)
4798                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
4799                 }
4800                 if (rsurface.texture->reflectmasktexture)
4801                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
4802                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
4803                 if (true || permutation & (SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_OFFSETMAPPING))
4804                 {
4805                         R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
4806                         R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
4807                         R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
4808                 }
4809                 else
4810                 {
4811                         R_Mesh_TexCoordPointer(1, 0, NULL, 0, 0);
4812                         R_Mesh_TexCoordPointer(2, 0, NULL, 0, 0);
4813                         R_Mesh_TexCoordPointer(3, 0, NULL, 0, 0);
4814                 }
4815                 //R_Mesh_TexCoordPointer(4, 0, NULL, 0, 0);
4816                 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND)
4817                         R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
4818                 else
4819                         R_Mesh_ColorPointer(NULL, 0, 0);
4820                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
4821                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
4822                 allow_colormod = R_BlendFuncAllowsColormod(GL_SRC_ALPHA, GL_ONE);
4823         }
4824         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
4825         {
4826                 if (r_glsl_offsetmapping.integer)
4827                 {
4828                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
4829                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4830                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
4831                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4832                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
4833                         {
4834                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4835                                 if (r_glsl_offsetmapping_reliefmapping.integer)
4836                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4837                         }
4838                 }
4839                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
4840                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
4841                 // unshaded geometry (fullbright or ambient model lighting)
4842                 mode = SHADERMODE_FLATCOLOR;
4843                 ambientscale = diffusescale = specularscale = 0;
4844                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
4845                         permutation |= SHADERPERMUTATION_GLOW;
4846                 if (r_refdef.fogenabled)
4847                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
4848                 if (rsurface.texture->colormapping)
4849                         permutation |= SHADERPERMUTATION_COLORMAPPING;
4850                 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
4851                 {
4852                         permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
4853                         if (r_shadow_usingshadowmaprect)
4854                                 permutation |= SHADERPERMUTATION_SHADOWMAPRECT;
4855                         if (r_shadow_usingshadowmap2d)
4856                                 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
4857
4858                         if (r_shadow_shadowmapsampler)
4859                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
4860                         if (r_shadow_shadowmappcf > 1)
4861                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
4862                         else if (r_shadow_shadowmappcf)
4863                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
4864                 }
4865                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
4866                         permutation |= SHADERPERMUTATION_REFLECTION;
4867                 if (rsurface.texture->reflectmasktexture)
4868                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
4869                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
4870                 if (true || permutation & (SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_OFFSETMAPPING))
4871                 {
4872                         R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
4873                         R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
4874                         R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
4875                 }
4876                 else
4877                 {
4878                         R_Mesh_TexCoordPointer(1, 0, NULL, 0, 0);
4879                         R_Mesh_TexCoordPointer(2, 0, NULL, 0, 0);
4880                         R_Mesh_TexCoordPointer(3, 0, NULL, 0, 0);
4881                 }
4882                 R_Mesh_TexCoordPointer(4, 0, NULL, 0, 0);
4883                 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND)
4884                         R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
4885                 else
4886                         R_Mesh_ColorPointer(NULL, 0, 0);
4887                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
4888                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
4889                 allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
4890         }
4891         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT_DIRECTIONAL)
4892         {
4893                 if (r_glsl_offsetmapping.integer)
4894                 {
4895                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
4896                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4897                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
4898                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4899                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
4900                         {
4901                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4902                                 if (r_glsl_offsetmapping_reliefmapping.integer)
4903                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4904                         }
4905                 }
4906                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
4907                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
4908                 // directional model lighting
4909                 mode = SHADERMODE_LIGHTDIRECTION;
4910                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
4911                         permutation |= SHADERPERMUTATION_GLOW;
4912                 permutation |= SHADERPERMUTATION_DIFFUSE;
4913                 if (specularscale > 0)
4914                 {
4915                         permutation |= SHADERPERMUTATION_SPECULAR;
4916                         if (r_shadow_glossexact.integer)
4917                                 permutation |= SHADERPERMUTATION_EXACTSPECULARMATH;
4918                 }
4919                 if (r_refdef.fogenabled)
4920                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
4921                 if (rsurface.texture->colormapping)
4922                         permutation |= SHADERPERMUTATION_COLORMAPPING;
4923                 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
4924                 {
4925                         permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
4926                         if (r_shadow_usingshadowmaprect)
4927                                 permutation |= SHADERPERMUTATION_SHADOWMAPRECT;
4928                         if (r_shadow_usingshadowmap2d)
4929                                 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
4930
4931                         if (r_shadow_shadowmapsampler)
4932                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
4933                         if (r_shadow_shadowmappcf > 1)
4934                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
4935                         else if (r_shadow_shadowmappcf)
4936                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
4937                 }
4938                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
4939                         permutation |= SHADERPERMUTATION_REFLECTION;
4940                 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
4941                         permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
4942                 if (rsurface.texture->reflectmasktexture)
4943                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
4944                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
4945                 if (true || permutation & (SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_OFFSETMAPPING))
4946                 {
4947                         R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
4948                         R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
4949                         R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
4950                 }
4951                 else
4952                 {
4953                         R_Mesh_TexCoordPointer(1, 0, NULL, 0, 0);
4954                         R_Mesh_TexCoordPointer(2, 0, NULL, 0, 0);
4955                         R_Mesh_TexCoordPointer(3, 0, NULL, 0, 0);
4956                 }
4957                 R_Mesh_TexCoordPointer(4, 0, NULL, 0, 0);
4958                 R_Mesh_ColorPointer(NULL, 0, 0);
4959                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
4960                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
4961                 allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
4962         }
4963         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
4964         {
4965                 if (r_glsl_offsetmapping.integer)
4966                 {
4967                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
4968                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4969                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
4970                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4971                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
4972                         {
4973                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4974                                 if (r_glsl_offsetmapping_reliefmapping.integer)
4975                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4976                         }
4977                 }
4978                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
4979                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
4980                 // ambient model lighting
4981                 mode = SHADERMODE_LIGHTDIRECTION;
4982                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
4983                         permutation |= SHADERPERMUTATION_GLOW;
4984                 if (r_refdef.fogenabled)
4985                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
4986                 if (rsurface.texture->colormapping)
4987                         permutation |= SHADERPERMUTATION_COLORMAPPING;
4988                 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
4989                 {
4990                         permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
4991                         if (r_shadow_usingshadowmaprect)
4992                                 permutation |= SHADERPERMUTATION_SHADOWMAPRECT;
4993                         if (r_shadow_usingshadowmap2d)
4994                                 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
4995
4996                         if (r_shadow_shadowmapsampler)
4997                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
4998                         if (r_shadow_shadowmappcf > 1)
4999                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
5000                         else if (r_shadow_shadowmappcf)
5001                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
5002                 }
5003                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
5004                         permutation |= SHADERPERMUTATION_REFLECTION;
5005                 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
5006                         permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
5007                 if (rsurface.texture->reflectmasktexture)
5008                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
5009                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
5010                 if (true || permutation & (SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_OFFSETMAPPING))
5011                 {
5012                         R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
5013                         R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
5014                         R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
5015                 }
5016                 else
5017                 {
5018                         R_Mesh_TexCoordPointer(1, 0, NULL, 0, 0);
5019                         R_Mesh_TexCoordPointer(2, 0, NULL, 0, 0);
5020                         R_Mesh_TexCoordPointer(3, 0, NULL, 0, 0);
5021                 }
5022                 R_Mesh_TexCoordPointer(4, 0, NULL, 0, 0);
5023                 R_Mesh_ColorPointer(NULL, 0, 0);
5024                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5025                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5026                 allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5027         }
5028         else
5029         {
5030                 if (r_glsl_offsetmapping.integer)
5031                 {
5032                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
5033                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5034                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
5035                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5036                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
5037                         {
5038                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5039                                 if (r_glsl_offsetmapping_reliefmapping.integer)
5040                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5041                         }
5042                 }
5043                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5044                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5045                 // lightmapped wall
5046                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
5047                         permutation |= SHADERPERMUTATION_GLOW;
5048                 if (r_refdef.fogenabled)
5049                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
5050                 if (rsurface.texture->colormapping)
5051                         permutation |= SHADERPERMUTATION_COLORMAPPING;
5052                 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
5053                 {
5054                         permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
5055                         if (r_shadow_usingshadowmaprect)
5056                                 permutation |= SHADERPERMUTATION_SHADOWMAPRECT;
5057                         if (r_shadow_usingshadowmap2d)
5058                                 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
5059
5060                         if (r_shadow_shadowmapsampler)
5061                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
5062                         if (r_shadow_shadowmappcf > 1)
5063                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
5064                         else if (r_shadow_shadowmappcf)
5065                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
5066                 }
5067                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
5068                         permutation |= SHADERPERMUTATION_REFLECTION;
5069                 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
5070                         permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
5071                 if (rsurface.texture->reflectmasktexture)
5072                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
5073                 if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping)
5074                 {
5075                         // deluxemapping (light direction texture)
5076                         if (rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping && r_refdef.scene.worldmodel->brushq3.deluxemapping_modelspace)
5077                                 mode = SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE;
5078                         else
5079                                 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
5080                         permutation |= SHADERPERMUTATION_DIFFUSE;
5081                         if (specularscale > 0)
5082                         {
5083                                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
5084                                 if (r_shadow_glossexact.integer)
5085                                         permutation |= SHADERPERMUTATION_EXACTSPECULARMATH;
5086                         }
5087                         R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
5088                         if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND)
5089                                 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5090                         else
5091                                 R_Mesh_ColorPointer(NULL, 0, 0);
5092                 }
5093                 else if (r_glsl_deluxemapping.integer >= 2)
5094                 {
5095                         // fake deluxemapping (uniform light direction in tangentspace)
5096                         mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
5097                         permutation |= SHADERPERMUTATION_DIFFUSE;
5098                         if (specularscale > 0)
5099                         {
5100                                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
5101                                 if (r_shadow_glossexact.integer)
5102                                         permutation |= SHADERPERMUTATION_EXACTSPECULARMATH;
5103                         }
5104                         R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
5105                         if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND)
5106                                 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5107                         else
5108                                 R_Mesh_ColorPointer(NULL, 0, 0);
5109                 }
5110                 else if (rsurface.uselightmaptexture)
5111                 {
5112                         // ordinary lightmapping (q1bsp, q3bsp)
5113                         mode = SHADERMODE_LIGHTMAP;
5114                         R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
5115                         if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND)
5116                                 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5117                         else
5118                                 R_Mesh_ColorPointer(NULL, 0, 0);
5119                 }
5120                 else
5121                 {
5122                         // ordinary vertex coloring (q3bsp)
5123                         mode = SHADERMODE_VERTEXCOLOR;
5124                         R_Mesh_TexCoordPointer(4, 0, NULL, 0, 0);
5125                         R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5126                 }
5127                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
5128                 if (true || permutation & (SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_OFFSETMAPPING))
5129                 {
5130                         R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
5131                         R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
5132                         R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
5133                 }
5134                 else
5135                 {
5136                         R_Mesh_TexCoordPointer(1, 0, NULL, 0, 0);
5137                         R_Mesh_TexCoordPointer(2, 0, NULL, 0, 0);
5138                         R_Mesh_TexCoordPointer(3, 0, NULL, 0, 0);
5139                 }
5140                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5141                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5142                 allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5143         }
5144         if(!allow_colormod)
5145                 colormod = dummy_colormod;
5146         switch(vid.renderpath)
5147         {
5148         case RENDERPATH_GL20:
5149                 R_SetupShader_SetPermutationGLSL(mode, permutation);
5150                 if (r_glsl_permutation->loc_ModelToReflectCube >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelToReflectCube, 1, false, m16f);}
5151                 if (mode == SHADERMODE_LIGHTSOURCE)
5152                 {
5153                         if (r_glsl_permutation->loc_ModelToLight >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelToLight, 1, false, m16f);}
5154                         if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
5155                         if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
5156                         if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, colormod[0] * ambientscale, colormod[1] * ambientscale, colormod[2] * ambientscale);
5157                         if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);
5158                         if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Specular, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale);
5159
5160                         // additive passes are only darkened by fog, not tinted
5161                         if (r_glsl_permutation->loc_FogColor >= 0)
5162                                 qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
5163                         if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));
5164                 }
5165                 else
5166                 {
5167                         if (mode == SHADERMODE_FLATCOLOR)
5168                         {
5169                                 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, colormod[0], colormod[1], colormod[2]);
5170                         }
5171                         else if (mode == SHADERMODE_LIGHTDIRECTION)
5172                         {
5173                                 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) * colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity) * colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity) * colormod[2]);
5174                                 if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, r_refdef.lightmapintensity * colormod[0], r_refdef.lightmapintensity * colormod[1], r_refdef.lightmapintensity * colormod[2]);
5175                                 if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);
5176                                 if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Diffuse, colormod[0] * r_shadow_deferred_8bitrange.value, colormod[1] * r_shadow_deferred_8bitrange.value, colormod[2] * r_shadow_deferred_8bitrange.value);
5177                                 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);
5178                                 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]);
5179                                 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]);
5180                         }
5181                         else
5182                         {
5183                                 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, r_refdef.scene.ambient * colormod[0], r_refdef.scene.ambient * colormod[1], r_refdef.scene.ambient * colormod[2]);
5184                                 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]);
5185                                 if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);
5186                                 if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Diffuse, colormod[0] * diffusescale * r_shadow_deferred_8bitrange.value, colormod[1] * diffusescale * r_shadow_deferred_8bitrange.value, colormod[2] * diffusescale * r_shadow_deferred_8bitrange.value);
5187                                 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);
5188                         }
5189                         // additive passes are only darkened by fog, not tinted
5190                         if (r_glsl_permutation->loc_FogColor >= 0)
5191                         {
5192                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
5193                                         qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
5194                                 else
5195                                         qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
5196                         }
5197                         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);
5198                         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]);
5199                         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]);
5200                         if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_RefractColor, 1, rsurface.texture->refractcolor4f);
5201                         if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_ReflectColor, 1, rsurface.texture->reflectcolor4f);
5202                         if (r_glsl_permutation->loc_ReflectFactor >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
5203                         if (r_glsl_permutation->loc_ReflectOffset >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectOffset, rsurface.texture->reflectmin);
5204                         if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));
5205                 }
5206                 if (r_glsl_permutation->loc_TexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_TexMatrix, 1, false, m16f);}
5207                 if (r_glsl_permutation->loc_BackgroundTexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_BackgroundTexMatrix, 1, false, m16f);}
5208                 if (r_glsl_permutation->loc_ShadowMapMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ShadowMapMatrix, 1, false, m16f);}
5209                 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]);
5210                 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]);
5211
5212                 if (r_glsl_permutation->loc_Color_Glow >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);
5213                 if (r_glsl_permutation->loc_Alpha >= 0) qglUniform1fARB(r_glsl_permutation->loc_Alpha, rsurface.texture->lightmapcolor[3]);
5214                 if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
5215                 if (r_glsl_permutation->loc_Color_Pants >= 0)
5216                 {
5217                         if (rsurface.texture->pantstexture)
5218                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
5219                         else
5220                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, 0, 0, 0);
5221                 }
5222                 if (r_glsl_permutation->loc_Color_Shirt >= 0)
5223                 {
5224                         if (rsurface.texture->shirttexture)
5225                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
5226                         else
5227                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
5228                 }
5229                 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]);
5230                 if (r_glsl_permutation->loc_FogPlaneViewDist >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogPlaneViewDist, rsurface.fogplaneviewdist);
5231                 if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, rsurface.fograngerecip);
5232                 if (r_glsl_permutation->loc_FogHeightFade >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogHeightFade, rsurface.fogheightfade);
5233                 if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value*rsurface.texture->offsetscale);
5234                 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]);
5235                 if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
5236
5237         //      if (r_glsl_permutation->loc_Texture_First           >= 0) R_Mesh_TexBind(GL20TU_FIRST             , r_texture_white                                     );
5238         //      if (r_glsl_permutation->loc_Texture_Second          >= 0) R_Mesh_TexBind(GL20TU_SECOND            , r_texture_white                                     );
5239         //      if (r_glsl_permutation->loc_Texture_GammaRamps      >= 0) R_Mesh_TexBind(GL20TU_GAMMARAMPS        , r_texture_gammaramps                                );
5240                 if (r_glsl_permutation->loc_Texture_Normal          >= 0) R_Mesh_TexBind(GL20TU_NORMAL            , rsurface.texture->nmaptexture                       );
5241                 if (r_glsl_permutation->loc_Texture_Color           >= 0) R_Mesh_TexBind(GL20TU_COLOR             , rsurface.texture->basetexture                       );
5242                 if (r_glsl_permutation->loc_Texture_Gloss           >= 0) R_Mesh_TexBind(GL20TU_GLOSS             , rsurface.texture->glosstexture                      );
5243                 if (r_glsl_permutation->loc_Texture_Glow            >= 0) R_Mesh_TexBind(GL20TU_GLOW              , rsurface.texture->glowtexture                       );
5244                 if (r_glsl_permutation->loc_Texture_SecondaryNormal >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL  , rsurface.texture->backgroundnmaptexture             );
5245                 if (r_glsl_permutation->loc_Texture_SecondaryColor  >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_COLOR   , rsurface.texture->backgroundbasetexture             );
5246                 if (r_glsl_permutation->loc_Texture_SecondaryGloss  >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS   , rsurface.texture->backgroundglosstexture            );
5247                 if (r_glsl_permutation->loc_Texture_SecondaryGlow   >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_GLOW    , rsurface.texture->backgroundglowtexture             );
5248                 if (r_glsl_permutation->loc_Texture_Pants           >= 0) R_Mesh_TexBind(GL20TU_PANTS             , rsurface.texture->pantstexture                      );
5249                 if (r_glsl_permutation->loc_Texture_Shirt           >= 0) R_Mesh_TexBind(GL20TU_SHIRT             , rsurface.texture->shirttexture                      );
5250                 if (r_glsl_permutation->loc_Texture_ReflectMask     >= 0) R_Mesh_TexBind(GL20TU_REFLECTMASK       , rsurface.texture->reflectmasktexture                );
5251                 if (r_glsl_permutation->loc_Texture_ReflectCube     >= 0) R_Mesh_TexBind(GL20TU_REFLECTCUBE       , rsurface.texture->reflectcubetexture ? rsurface.texture->reflectcubetexture : r_texture_whitecube);
5252                 if (r_glsl_permutation->loc_Texture_FogHeightTexture>= 0) R_Mesh_TexBind(GL20TU_FOGHEIGHTTEXTURE  , r_texture_fogheighttexture                          );
5253                 if (r_glsl_permutation->loc_Texture_FogMask         >= 0) R_Mesh_TexBind(GL20TU_FOGMASK           , r_texture_fogattenuation                            );
5254                 if (r_glsl_permutation->loc_Texture_Lightmap        >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP          , r_texture_white                                     );
5255                 if (r_glsl_permutation->loc_Texture_Deluxemap       >= 0) R_Mesh_TexBind(GL20TU_DELUXEMAP         , r_texture_blanknormalmap                            );
5256                 if (r_glsl_permutation->loc_Texture_Attenuation     >= 0) R_Mesh_TexBind(GL20TU_ATTENUATION       , r_shadow_attenuationgradienttexture                 );
5257                 if (r_glsl_permutation->loc_Texture_Refraction      >= 0) R_Mesh_TexBind(GL20TU_REFRACTION        , r_texture_white                                     );
5258                 if (r_glsl_permutation->loc_Texture_Reflection      >= 0) R_Mesh_TexBind(GL20TU_REFLECTION        , r_texture_white                                     );
5259                 if (r_glsl_permutation->loc_Texture_ScreenDepth     >= 0) R_Mesh_TexBind(GL20TU_SCREENDEPTH       , r_shadow_prepassgeometrydepthtexture                );
5260                 if (r_glsl_permutation->loc_Texture_ScreenNormalMap >= 0) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP   , r_shadow_prepassgeometrynormalmaptexture            );
5261                 if (r_glsl_permutation->loc_Texture_ScreenDiffuse   >= 0) R_Mesh_TexBind(GL20TU_SCREENDIFFUSE     , r_shadow_prepasslightingdiffusetexture              );
5262                 if (r_glsl_permutation->loc_Texture_ScreenSpecular  >= 0) R_Mesh_TexBind(GL20TU_SCREENSPECULAR    , r_shadow_prepasslightingspeculartexture             );
5263                 if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)))
5264                 {
5265                         if (r_glsl_permutation->loc_Texture_ShadowMap2D     >= 0) R_Mesh_TexBind(r_shadow_usingshadowmaportho ? GL20TU_SHADOWMAPORTHO2D : GL20TU_SHADOWMAP2D, r_shadow_shadowmap2dtexture                         );
5266                         if (r_glsl_permutation->loc_Texture_ShadowMapRect   >= 0) R_Mesh_TexBind(r_shadow_usingshadowmaportho ? GL20TU_SHADOWMAPORTHORECT : GL20TU_SHADOWMAPRECT, r_shadow_shadowmaprectangletexture                  );
5267                         if (rsurface.rtlight)
5268                         {
5269                                 if (r_glsl_permutation->loc_Texture_Cube            >= 0) R_Mesh_TexBind(GL20TU_CUBE              , rsurface.rtlight->currentcubemap                    );
5270                                 if (r_shadow_usingshadowmapcube)
5271                                         if (r_glsl_permutation->loc_Texture_ShadowMapCube   >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAPCUBE     , r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]);
5272                                 if (r_glsl_permutation->loc_Texture_CubeProjection  >= 0) R_Mesh_TexBind(GL20TU_CUBEPROJECTION    , r_shadow_shadowmapvsdcttexture                      );
5273                         }
5274                 }
5275                 CHECKGLERROR
5276                 break;
5277         case RENDERPATH_CGGL:
5278 #ifdef SUPPORTCG
5279                 R_SetupShader_SetPermutationCG(mode, permutation);
5280                 if (r_cg_permutation->fp_ModelToReflectCube) {Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->fp_ModelToReflectCube, m16f);}CHECKCGERROR
5281                 if (mode == SHADERMODE_LIGHTSOURCE)
5282                 {
5283                         if (r_cg_permutation->vp_ModelToLight) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelToLight, m16f);}CHECKCGERROR
5284                         if (r_cg_permutation->vp_LightPosition) cgGLSetParameter3f(r_cg_permutation->vp_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);CHECKCGERROR
5285                 }
5286                 else
5287                 {
5288                         if (mode == SHADERMODE_LIGHTDIRECTION)
5289                         {
5290                                 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
5291                         }
5292                 }
5293                 if (r_cg_permutation->vp_TexMatrix) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_TexMatrix, m16f);}CHECKCGERROR
5294                 if (r_cg_permutation->vp_BackgroundTexMatrix) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_BackgroundTexMatrix, m16f);}CHECKCGERROR
5295                 if (r_cg_permutation->vp_ShadowMapMatrix) {Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_ShadowMapMatrix, m16f);}CHECKGLERROR
5296                 if (r_cg_permutation->vp_EyePosition) cgGLSetParameter3f(r_cg_permutation->vp_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);CHECKCGERROR
5297                 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
5298                 CHECKGLERROR
5299
5300                 if (mode == SHADERMODE_LIGHTSOURCE)
5301                 {
5302                         if (r_cg_permutation->fp_LightPosition) cgGLSetParameter3f(r_cg_permutation->fp_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);CHECKCGERROR
5303                         if (r_cg_permutation->fp_LightColor) cgGLSetParameter3f(r_cg_permutation->fp_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);CHECKCGERROR
5304                         if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, colormod[0] * ambientscale, colormod[1] * ambientscale, colormod[2] * ambientscale);CHECKCGERROR
5305                         if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);CHECKCGERROR
5306                         if (r_cg_permutation->fp_Color_Specular) cgGLSetParameter3f(r_cg_permutation->fp_Color_Specular, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale);CHECKCGERROR
5307
5308                         // additive passes are only darkened by fog, not tinted
5309                         if (r_cg_permutation->fp_FogColor) cgGLSetParameter3f(r_cg_permutation->fp_FogColor, 0, 0, 0);CHECKCGERROR
5310                         if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR
5311                 }
5312                 else
5313                 {
5314                         if (mode == SHADERMODE_FLATCOLOR)
5315                         {
5316                                 if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, colormod[0], colormod[1], colormod[2]);CHECKCGERROR
5317                         }
5318                         else if (mode == SHADERMODE_LIGHTDIRECTION)
5319                         {
5320                                 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) * colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity) * colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity) * colormod[2]);CHECKCGERROR
5321                                 if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, r_refdef.lightmapintensity * colormod[0], r_refdef.lightmapintensity * colormod[1], r_refdef.lightmapintensity * colormod[2]);CHECKCGERROR
5322                                 if (r_cg_permutation->fp_Color_Specular) cgGLSetParameter3f(r_cg_permutation->fp_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);CHECKCGERROR
5323                                 if (r_cg_permutation->fp_DeferredMod_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Diffuse, colormod[0] * r_shadow_deferred_8bitrange.value, colormod[1] * r_shadow_deferred_8bitrange.value, colormod[2] * r_shadow_deferred_8bitrange.value);CHECKCGERROR
5324                                 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
5325                                 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
5326                                 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
5327                         }
5328                         else
5329                         {
5330                                 if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, r_refdef.scene.ambient * colormod[0], r_refdef.scene.ambient * colormod[1], r_refdef.scene.ambient * colormod[2]);CHECKCGERROR
5331                                 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
5332                                 if (r_cg_permutation->fp_Color_Specular) cgGLSetParameter3f(r_cg_permutation->fp_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);CHECKCGERROR
5333                                 if (r_cg_permutation->fp_DeferredMod_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Diffuse, colormod[0] * diffusescale * r_shadow_deferred_8bitrange.value, colormod[1] * diffusescale * r_shadow_deferred_8bitrange.value, colormod[2] * diffusescale * r_shadow_deferred_8bitrange.value);CHECKCGERROR
5334                                 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
5335                         }
5336                         // additive passes are only darkened by fog, not tinted
5337                         if (r_cg_permutation->fp_FogColor)
5338                         {
5339                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
5340                                         cgGLSetParameter3f(r_cg_permutation->fp_FogColor, 0, 0, 0);
5341                                 else
5342                                         cgGLSetParameter3f(r_cg_permutation->fp_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
5343                                 CHECKCGERROR
5344                         }
5345                         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
5346                         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
5347                         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
5348                         if (r_cg_permutation->fp_RefractColor) cgGLSetParameter4fv(r_cg_permutation->fp_RefractColor, rsurface.texture->refractcolor4f);CHECKCGERROR
5349                         if (r_cg_permutation->fp_ReflectColor) cgGLSetParameter4fv(r_cg_permutation->fp_ReflectColor, rsurface.texture->reflectcolor4f);CHECKCGERROR
5350                         if (r_cg_permutation->fp_ReflectFactor) cgGLSetParameter1f(r_cg_permutation->fp_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);CHECKCGERROR
5351                         if (r_cg_permutation->fp_ReflectOffset) cgGLSetParameter1f(r_cg_permutation->fp_ReflectOffset, rsurface.texture->reflectmin);CHECKCGERROR
5352                         if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR
5353                 }
5354                 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
5355                 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
5356                 if (r_cg_permutation->fp_Color_Glow) cgGLSetParameter3f(r_cg_permutation->fp_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);CHECKCGERROR
5357                 if (r_cg_permutation->fp_Alpha) cgGLSetParameter1f(r_cg_permutation->fp_Alpha, rsurface.texture->lightmapcolor[3]);CHECKCGERROR
5358                 if (r_cg_permutation->fp_EyePosition) cgGLSetParameter3f(r_cg_permutation->fp_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);CHECKCGERROR
5359                 if (r_cg_permutation->fp_Color_Pants)
5360                 {
5361                         if (rsurface.texture->pantstexture)
5362                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
5363                         else
5364                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Pants, 0, 0, 0);
5365                         CHECKCGERROR
5366                 }
5367                 if (r_cg_permutation->fp_Color_Shirt)
5368                 {
5369                         if (rsurface.texture->shirttexture)
5370                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
5371                         else
5372                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Shirt, 0, 0, 0);
5373                         CHECKCGERROR
5374                 }
5375                 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
5376                 if (r_cg_permutation->fp_FogPlaneViewDist) cgGLSetParameter1f(r_cg_permutation->fp_FogPlaneViewDist, rsurface.fogplaneviewdist);CHECKCGERROR
5377                 if (r_cg_permutation->fp_FogRangeRecip) cgGLSetParameter1f(r_cg_permutation->fp_FogRangeRecip, rsurface.fograngerecip);CHECKCGERROR
5378                 if (r_cg_permutation->fp_FogHeightFade) cgGLSetParameter1f(r_cg_permutation->fp_FogHeightFade, rsurface.fogheightfade);CHECKCGERROR
5379                 if (r_cg_permutation->fp_OffsetMapping_Scale) cgGLSetParameter1f(r_cg_permutation->fp_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);CHECKCGERROR
5380                 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
5381                 if (r_cg_permutation->fp_PixelToScreenTexCoord) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR
5382
5383         //      if (r_cg_permutation->fp_Texture_First          ) CG_BindTexture(r_cg_permutation->fp_Texture_First          , r_texture_white                                     );CHECKCGERROR
5384         //      if (r_cg_permutation->fp_Texture_Second         ) CG_BindTexture(r_cg_permutation->fp_Texture_Second         , r_texture_white                                     );CHECKCGERROR
5385         //      if (r_cg_permutation->fp_Texture_GammaRamps     ) CG_BindTexture(r_cg_permutation->fp_Texture_GammaRamps     , r_texture_gammaramps                                );CHECKCGERROR
5386                 if (r_cg_permutation->fp_Texture_Normal         ) CG_BindTexture(r_cg_permutation->fp_Texture_Normal         , rsurface.texture->nmaptexture                       );CHECKCGERROR
5387                 if (r_cg_permutation->fp_Texture_Color          ) CG_BindTexture(r_cg_permutation->fp_Texture_Color          , rsurface.texture->basetexture                       );CHECKCGERROR
5388                 if (r_cg_permutation->fp_Texture_Gloss          ) CG_BindTexture(r_cg_permutation->fp_Texture_Gloss          , rsurface.texture->glosstexture                      );CHECKCGERROR
5389                 if (r_cg_permutation->fp_Texture_Glow           ) CG_BindTexture(r_cg_permutation->fp_Texture_Glow           , rsurface.texture->glowtexture                       );CHECKCGERROR
5390                 if (r_cg_permutation->fp_Texture_SecondaryNormal) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryNormal, rsurface.texture->backgroundnmaptexture             );CHECKCGERROR
5391                 if (r_cg_permutation->fp_Texture_SecondaryColor ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryColor , rsurface.texture->backgroundbasetexture             );CHECKCGERROR
5392                 if (r_cg_permutation->fp_Texture_SecondaryGloss ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryGloss , rsurface.texture->backgroundglosstexture            );CHECKCGERROR
5393                 if (r_cg_permutation->fp_Texture_SecondaryGlow  ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryGlow  , rsurface.texture->backgroundglowtexture             );CHECKCGERROR
5394                 if (r_cg_permutation->fp_Texture_Pants          ) CG_BindTexture(r_cg_permutation->fp_Texture_Pants          , rsurface.texture->pantstexture                      );CHECKCGERROR
5395                 if (r_cg_permutation->fp_Texture_Shirt          ) CG_BindTexture(r_cg_permutation->fp_Texture_Shirt          , rsurface.texture->shirttexture                      );CHECKCGERROR
5396                 if (r_cg_permutation->fp_Texture_ReflectMask    ) CG_BindTexture(r_cg_permutation->fp_Texture_ReflectMask    , rsurface.texture->reflectmasktexture                );CHECKCGERROR
5397                 if (r_cg_permutation->fp_Texture_ReflectCube    ) CG_BindTexture(r_cg_permutation->fp_Texture_ReflectCube    , rsurface.texture->reflectcubetexture ? rsurface.texture->reflectcubetexture : r_texture_whitecube);CHECKCGERROR
5398                 if (r_cg_permutation->fp_Texture_FogHeightTexture) CG_BindTexture(r_cg_permutation->fp_Texture_FogHeightTexture, r_texture_fogheighttexture                         );CHECKCGERROR
5399                 if (r_cg_permutation->fp_Texture_FogMask        ) CG_BindTexture(r_cg_permutation->fp_Texture_FogMask        , r_texture_fogattenuation                            );CHECKCGERROR
5400                 if (r_cg_permutation->fp_Texture_Lightmap       ) CG_BindTexture(r_cg_permutation->fp_Texture_Lightmap       , r_texture_white                                     );CHECKCGERROR
5401                 if (r_cg_permutation->fp_Texture_Deluxemap      ) CG_BindTexture(r_cg_permutation->fp_Texture_Deluxemap      , r_texture_blanknormalmap                            );CHECKCGERROR
5402                 if (r_cg_permutation->fp_Texture_Attenuation    ) CG_BindTexture(r_cg_permutation->fp_Texture_Attenuation    , r_shadow_attenuationgradienttexture                 );CHECKCGERROR
5403                 if (r_cg_permutation->fp_Texture_Refraction     ) CG_BindTexture(r_cg_permutation->fp_Texture_Refraction     , r_texture_white                                     );CHECKCGERROR
5404                 if (r_cg_permutation->fp_Texture_Reflection     ) CG_BindTexture(r_cg_permutation->fp_Texture_Reflection     , r_texture_white                                     );CHECKCGERROR
5405                 if (r_cg_permutation->fp_Texture_ScreenDepth    ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDepth    , r_shadow_prepassgeometrydepthtexture                );CHECKCGERROR
5406                 if (r_cg_permutation->fp_Texture_ScreenNormalMap) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenNormalMap, r_shadow_prepassgeometrynormalmaptexture            );CHECKCGERROR
5407                 if (r_cg_permutation->fp_Texture_ScreenDiffuse  ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDiffuse  , r_shadow_prepasslightingdiffusetexture              );CHECKCGERROR
5408                 if (r_cg_permutation->fp_Texture_ScreenSpecular ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenSpecular , r_shadow_prepasslightingspeculartexture             );CHECKCGERROR
5409                 if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)))
5410                 {
5411                         if (r_cg_permutation->fp_Texture_ShadowMap2D    ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMap2D    , r_shadow_shadowmap2dtexture                         );CHECKCGERROR
5412                         if (r_cg_permutation->fp_Texture_ShadowMapRect  ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapRect  , r_shadow_shadowmaprectangletexture                  );CHECKCGERROR
5413                         if (rsurface.rtlight)
5414                         {
5415                                 if (r_cg_permutation->fp_Texture_Cube           ) CG_BindTexture(r_cg_permutation->fp_Texture_Cube           , rsurface.rtlight->currentcubemap                    );CHECKCGERROR
5416                                 if (r_shadow_usingshadowmapcube)
5417                                         if (r_cg_permutation->fp_Texture_ShadowMapCube  ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapCube  , r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]);CHECKCGERROR
5418                                 if (r_cg_permutation->fp_Texture_CubeProjection ) CG_BindTexture(r_cg_permutation->fp_Texture_CubeProjection , r_shadow_shadowmapvsdcttexture                      );CHECKCGERROR
5419                         }
5420                 }
5421
5422                 CHECKGLERROR
5423 #endif
5424                 break;
5425         case RENDERPATH_GL13:
5426         case RENDERPATH_GL11:
5427                 break;
5428         }
5429 }
5430
5431 void R_SetupShader_DeferredLight(const rtlight_t *rtlight)
5432 {
5433         // select a permutation of the lighting shader appropriate to this
5434         // combination of texture, entity, light source, and fogging, only use the
5435         // minimum features necessary to avoid wasting rendering time in the
5436         // fragment shader on features that are not being used
5437         unsigned int permutation = 0;
5438         unsigned int mode = 0;
5439         const float *lightcolorbase = rtlight->currentcolor;
5440         float ambientscale = rtlight->ambientscale;
5441         float diffusescale = rtlight->diffusescale;
5442         float specularscale = rtlight->specularscale;
5443         // this is the location of the light in view space
5444         vec3_t viewlightorigin;
5445         // this transforms from view space (camera) to light space (cubemap)
5446         matrix4x4_t viewtolight;
5447         matrix4x4_t lighttoview;
5448         float viewtolight16f[16];
5449         float range = 1.0f / r_shadow_deferred_8bitrange.value;
5450         // light source
5451         mode = SHADERMODE_DEFERREDLIGHTSOURCE;
5452         if (rtlight->currentcubemap != r_texture_whitecube)
5453                 permutation |= SHADERPERMUTATION_CUBEFILTER;
5454         if (diffusescale > 0)
5455                 permutation |= SHADERPERMUTATION_DIFFUSE;
5456         if (specularscale > 0)
5457         {
5458                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
5459                 if (r_shadow_glossexact.integer)
5460                         permutation |= SHADERPERMUTATION_EXACTSPECULARMATH;
5461         }
5462         if (r_shadow_usingshadowmaprect || r_shadow_usingshadowmap2d || r_shadow_usingshadowmapcube)
5463         {
5464                 if (r_shadow_usingshadowmaprect)
5465                         permutation |= SHADERPERMUTATION_SHADOWMAPRECT;
5466                 if (r_shadow_usingshadowmap2d)
5467                         permutation |= SHADERPERMUTATION_SHADOWMAP2D;
5468                 if (r_shadow_usingshadowmapcube)
5469                         permutation |= SHADERPERMUTATION_SHADOWMAPCUBE;
5470                 else if(r_shadow_shadowmapvsdct)
5471                         permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT;
5472
5473                 if (r_shadow_shadowmapsampler)
5474                         permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
5475                 if (r_shadow_shadowmappcf > 1)
5476                         permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
5477                 else if (r_shadow_shadowmappcf)
5478                         permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
5479         }
5480         Matrix4x4_Transform(&r_refdef.view.viewport.viewmatrix, rtlight->shadoworigin, viewlightorigin);
5481         Matrix4x4_Concat(&lighttoview, &r_refdef.view.viewport.viewmatrix, &rtlight->matrix_lighttoworld);
5482         Matrix4x4_Invert_Simple(&viewtolight, &lighttoview);
5483         Matrix4x4_ToArrayFloatGL(&viewtolight, viewtolight16f);
5484         switch(vid.renderpath)
5485         {
5486         case RENDERPATH_GL20:
5487                 R_SetupShader_SetPermutationGLSL(mode, permutation);
5488                 if (r_glsl_permutation->loc_LightPosition             >= 0) qglUniform3fARB(       r_glsl_permutation->loc_LightPosition            , viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);
5489                 if (r_glsl_permutation->loc_ViewToLight               >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ViewToLight              , 1, false, viewtolight16f);
5490                 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);
5491                 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);
5492                 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);
5493                 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]);
5494                 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]);
5495                 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));
5496                 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]);
5497                 if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
5498
5499                 if (r_glsl_permutation->loc_Texture_Attenuation       >= 0) R_Mesh_TexBind(GL20TU_ATTENUATION        , r_shadow_attenuationgradienttexture                 );
5500                 if (r_glsl_permutation->loc_Texture_ScreenDepth       >= 0) R_Mesh_TexBind(GL20TU_SCREENDEPTH        , r_shadow_prepassgeometrydepthtexture                );
5501                 if (r_glsl_permutation->loc_Texture_ScreenNormalMap   >= 0) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP    , r_shadow_prepassgeometrynormalmaptexture            );
5502                 if (r_glsl_permutation->loc_Texture_Cube              >= 0) R_Mesh_TexBind(GL20TU_CUBE               , rsurface.rtlight->currentcubemap                    );
5503                 if (r_glsl_permutation->loc_Texture_ShadowMapRect     >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAPRECT      , r_shadow_shadowmaprectangletexture                  );
5504                 if (r_shadow_usingshadowmapcube)
5505                         if (r_glsl_permutation->loc_Texture_ShadowMapCube     >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAPCUBE      , r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]);
5506                 if (r_glsl_permutation->loc_Texture_ShadowMap2D       >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAP2D        , r_shadow_shadowmap2dtexture                         );
5507                 if (r_glsl_permutation->loc_Texture_CubeProjection    >= 0) R_Mesh_TexBind(GL20TU_CUBEPROJECTION     , r_shadow_shadowmapvsdcttexture                      );
5508                 break;
5509         case RENDERPATH_CGGL:
5510 #ifdef SUPPORTCG
5511                 R_SetupShader_SetPermutationCG(mode, permutation);
5512                 if (r_cg_permutation->fp_LightPosition            ) cgGLSetParameter3f(r_cg_permutation->fp_LightPosition, viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);CHECKCGERROR
5513                 if (r_cg_permutation->fp_ViewToLight              ) cgGLSetMatrixParameterfc(r_cg_permutation->fp_ViewToLight, viewtolight16f);CHECKCGERROR
5514                 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
5515                 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
5516                 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
5517                 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
5518                 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
5519                 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
5520                 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
5521                 if (r_cg_permutation->fp_PixelToScreenTexCoord    ) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR
5522
5523                 if (r_cg_permutation->fp_Texture_Attenuation      ) CG_BindTexture(r_cg_permutation->fp_Texture_Attenuation    , r_shadow_attenuationgradienttexture                 );CHECKCGERROR
5524                 if (r_cg_permutation->fp_Texture_ScreenDepth      ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDepth    , r_shadow_prepassgeometrydepthtexture                );CHECKCGERROR
5525                 if (r_cg_permutation->fp_Texture_ScreenNormalMap  ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenNormalMap, r_shadow_prepassgeometrynormalmaptexture            );CHECKCGERROR
5526                 if (r_cg_permutation->fp_Texture_Cube             ) CG_BindTexture(r_cg_permutation->fp_Texture_Cube           , rsurface.rtlight->currentcubemap                    );CHECKCGERROR
5527                 if (r_cg_permutation->fp_Texture_ShadowMapRect    ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapRect  , r_shadow_shadowmaprectangletexture                  );CHECKCGERROR
5528                 if (r_shadow_usingshadowmapcube)
5529                         if (r_cg_permutation->fp_Texture_ShadowMapCube    ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapCube  , r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]);CHECKCGERROR
5530                 if (r_cg_permutation->fp_Texture_ShadowMap2D      ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMap2D    , r_shadow_shadowmap2dtexture                         );CHECKCGERROR
5531                 if (r_cg_permutation->fp_Texture_CubeProjection   ) CG_BindTexture(r_cg_permutation->fp_Texture_CubeProjection , r_shadow_shadowmapvsdcttexture                      );CHECKCGERROR
5532 #endif
5533                 break;
5534         case RENDERPATH_GL13:
5535         case RENDERPATH_GL11:
5536                 break;
5537         }
5538 }
5539
5540 #define SKINFRAME_HASH 1024
5541
5542 typedef struct
5543 {
5544         int loadsequence; // incremented each level change
5545         memexpandablearray_t array;
5546         skinframe_t *hash[SKINFRAME_HASH];
5547 }
5548 r_skinframe_t;
5549 r_skinframe_t r_skinframe;
5550
5551 void R_SkinFrame_PrepareForPurge(void)
5552 {
5553         r_skinframe.loadsequence++;
5554         // wrap it without hitting zero
5555         if (r_skinframe.loadsequence >= 200)
5556                 r_skinframe.loadsequence = 1;
5557 }
5558
5559 void R_SkinFrame_MarkUsed(skinframe_t *skinframe)
5560 {
5561         if (!skinframe)
5562                 return;
5563         // mark the skinframe as used for the purging code
5564         skinframe->loadsequence = r_skinframe.loadsequence;
5565 }
5566
5567 void R_SkinFrame_Purge(void)
5568 {
5569         int i;
5570         skinframe_t *s;
5571         for (i = 0;i < SKINFRAME_HASH;i++)
5572         {
5573                 for (s = r_skinframe.hash[i];s;s = s->next)
5574                 {
5575                         if (s->loadsequence && s->loadsequence != r_skinframe.loadsequence)
5576                         {
5577                                 if (s->merged == s->base)
5578                                         s->merged = NULL;
5579                                 // FIXME: maybe pass a pointer to the pointer to R_PurgeTexture and reset it to NULL inside? [11/29/2007 Black]
5580                                 R_PurgeTexture(s->stain );s->stain  = NULL;
5581                                 R_PurgeTexture(s->merged);s->merged = NULL;
5582                                 R_PurgeTexture(s->base  );s->base   = NULL;
5583                                 R_PurgeTexture(s->pants );s->pants  = NULL;
5584                                 R_PurgeTexture(s->shirt );s->shirt  = NULL;
5585                                 R_PurgeTexture(s->nmap  );s->nmap   = NULL;
5586                                 R_PurgeTexture(s->gloss );s->gloss  = NULL;
5587                                 R_PurgeTexture(s->glow  );s->glow   = NULL;
5588                                 R_PurgeTexture(s->fog   );s->fog    = NULL;
5589                                 R_PurgeTexture(s->reflect);s->reflect = NULL;
5590                                 s->loadsequence = 0;
5591                         }
5592                 }
5593         }
5594 }
5595
5596 skinframe_t *R_SkinFrame_FindNextByName( skinframe_t *last, const char *name ) {
5597         skinframe_t *item;
5598         char basename[MAX_QPATH];
5599
5600         Image_StripImageExtension(name, basename, sizeof(basename));
5601
5602         if( last == NULL ) {
5603                 int hashindex;
5604                 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
5605                 item = r_skinframe.hash[hashindex];
5606         } else {
5607                 item = last->next;
5608         }
5609
5610         // linearly search through the hash bucket
5611         for( ; item ; item = item->next ) {
5612                 if( !strcmp( item->basename, basename ) ) {
5613                         return item;
5614                 }
5615         }
5616         return NULL;
5617 }
5618
5619 skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qboolean add)
5620 {
5621         skinframe_t *item;
5622         int hashindex;
5623         char basename[MAX_QPATH];
5624
5625         Image_StripImageExtension(name, basename, sizeof(basename));
5626
5627         hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
5628         for (item = r_skinframe.hash[hashindex];item;item = item->next)
5629                 if (!strcmp(item->basename, basename) && item->textureflags == textureflags && item->comparewidth == comparewidth && item->compareheight == compareheight && item->comparecrc == comparecrc)
5630                         break;
5631
5632         if (!item) {
5633                 rtexture_t *dyntexture;
5634                 // check whether its a dynamic texture
5635                 dyntexture = CL_GetDynTexture( basename );
5636                 if (!add && !dyntexture)
5637                         return NULL;
5638                 item = (skinframe_t *)Mem_ExpandableArray_AllocRecord(&r_skinframe.array);
5639                 memset(item, 0, sizeof(*item));
5640                 strlcpy(item->basename, basename, sizeof(item->basename));
5641                 item->base = dyntexture; // either NULL or dyntexture handle
5642                 item->textureflags = textureflags;
5643                 item->comparewidth = comparewidth;
5644                 item->compareheight = compareheight;
5645                 item->comparecrc = comparecrc;
5646                 item->next = r_skinframe.hash[hashindex];
5647                 r_skinframe.hash[hashindex] = item;
5648         }
5649         else if( item->base == NULL )
5650         {
5651                 rtexture_t *dyntexture;
5652                 // check whether its a dynamic texture
5653                 // 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]
5654                 dyntexture = CL_GetDynTexture( basename );
5655                 item->base = dyntexture; // either NULL or dyntexture handle
5656         }
5657
5658         R_SkinFrame_MarkUsed(item);
5659         return item;
5660 }
5661
5662 #define R_SKINFRAME_LOAD_AVERAGE_COLORS(cnt, getpixel) \
5663         { \
5664                 unsigned long long avgcolor[5], wsum; \
5665                 int pix, comp, w; \
5666                 avgcolor[0] = 0; \
5667                 avgcolor[1] = 0; \
5668                 avgcolor[2] = 0; \
5669                 avgcolor[3] = 0; \
5670                 avgcolor[4] = 0; \
5671                 wsum = 0; \
5672                 for(pix = 0; pix < cnt; ++pix) \
5673                 { \
5674                         w = 0; \
5675                         for(comp = 0; comp < 3; ++comp) \
5676                                 w += getpixel; \
5677                         if(w) /* ignore perfectly black pixels because that is better for model skins */ \
5678                         { \
5679                                 ++wsum; \
5680                                 /* comp = 3; -- not needed, comp is always 3 when we get here */ \
5681                                 w = getpixel; \
5682                                 for(comp = 0; comp < 3; ++comp) \
5683                                         avgcolor[comp] += getpixel * w; \
5684                                 avgcolor[3] += w; \
5685                         } \
5686                         /* comp = 3; -- not needed, comp is always 3 when we get here */ \
5687                         avgcolor[4] += getpixel; \
5688                 } \
5689                 if(avgcolor[3] == 0) /* no pixels seen? even worse */ \
5690                         avgcolor[3] = 1; \
5691                 skinframe->avgcolor[0] = avgcolor[2] / (255.0 * avgcolor[3]); \
5692                 skinframe->avgcolor[1] = avgcolor[1] / (255.0 * avgcolor[3]); \
5693                 skinframe->avgcolor[2] = avgcolor[0] / (255.0 * avgcolor[3]); \
5694                 skinframe->avgcolor[3] = avgcolor[4] / (255.0 * cnt); \
5695         }
5696
5697 extern cvar_t gl_picmip;
5698 skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain)
5699 {
5700         int j;
5701         unsigned char *pixels;
5702         unsigned char *bumppixels;
5703         unsigned char *basepixels = NULL;
5704         int basepixels_width = 0;
5705         int basepixels_height = 0;
5706         skinframe_t *skinframe;
5707         rtexture_t *ddsbase = NULL;
5708         qboolean ddshasalpha = false;
5709         float ddsavgcolor[4];
5710         char basename[MAX_QPATH];
5711         int miplevel = R_PicmipForFlags(textureflags);
5712         int savemiplevel = miplevel;
5713         int mymiplevel;
5714
5715         if (cls.state == ca_dedicated)
5716                 return NULL;
5717
5718         // return an existing skinframe if already loaded
5719         // if loading of the first image fails, don't make a new skinframe as it
5720         // would cause all future lookups of this to be missing
5721         skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
5722         if (skinframe && skinframe->base)
5723                 return skinframe;
5724
5725         Image_StripImageExtension(name, basename, sizeof(basename));
5726
5727         // check for DDS texture file first
5728         if (!r_loaddds || !(ddsbase = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s.dds", basename), textureflags, &ddshasalpha, ddsavgcolor, miplevel)))
5729         {
5730                 basepixels = loadimagepixelsbgra(name, complain, true, r_texture_convertsRGB_skin.integer, &miplevel);
5731                 if (basepixels == NULL)
5732                         return NULL;
5733         }
5734
5735         // FIXME handle miplevel
5736
5737         if (developer_loading.integer)
5738                 Con_Printf("loading skin \"%s\"\n", name);
5739
5740         // we've got some pixels to store, so really allocate this new texture now
5741         if (!skinframe)
5742                 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, true);
5743         skinframe->stain = NULL;
5744         skinframe->merged = NULL;
5745         skinframe->base = NULL;
5746         skinframe->pants = NULL;
5747         skinframe->shirt = NULL;
5748         skinframe->nmap = NULL;
5749         skinframe->gloss = NULL;
5750         skinframe->glow = NULL;
5751         skinframe->fog = NULL;
5752         skinframe->reflect = NULL;
5753         skinframe->hasalpha = false;
5754
5755         if (ddsbase)
5756         {
5757                 skinframe->base = ddsbase;
5758                 skinframe->hasalpha = ddshasalpha;
5759                 VectorCopy(ddsavgcolor, skinframe->avgcolor);
5760                 if (r_loadfog && skinframe->hasalpha)
5761                         skinframe->fog = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_mask.dds", skinframe->basename), textureflags | TEXF_ALPHA, NULL, NULL, miplevel);
5762                 //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]);
5763         }
5764         else
5765         {
5766                 basepixels_width = image_width;
5767                 basepixels_height = image_height;
5768                 skinframe->base = R_LoadTexture2D (r_main_texturepool, skinframe->basename, basepixels_width, basepixels_height, basepixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), miplevel, NULL);
5769                 if (textureflags & TEXF_ALPHA)
5770                 {
5771                         for (j = 3;j < basepixels_width * basepixels_height * 4;j += 4)
5772                         {
5773                                 if (basepixels[j] < 255)
5774                                 {
5775                                         skinframe->hasalpha = true;
5776                                         break;
5777                                 }
5778                         }
5779                         if (r_loadfog && skinframe->hasalpha)
5780                         {
5781                                 // has transparent pixels
5782                                 pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
5783                                 for (j = 0;j < image_width * image_height * 4;j += 4)
5784                                 {
5785                                         pixels[j+0] = 255;
5786                                         pixels[j+1] = 255;
5787                                         pixels[j+2] = 255;
5788                                         pixels[j+3] = basepixels[j+3];
5789                                 }
5790                                 skinframe->fog = R_LoadTexture2D (r_main_texturepool, va("%s_mask", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), miplevel, NULL);
5791                                 Mem_Free(pixels);
5792                         }
5793                 }
5794                 R_SKINFRAME_LOAD_AVERAGE_COLORS(basepixels_width * basepixels_height, basepixels[4 * pix + comp]);
5795                 //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]);
5796                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->base)
5797                         R_SaveTextureDDSFile(skinframe->base, va("dds/%s.dds", skinframe->basename), true, skinframe->hasalpha);
5798                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->fog)
5799                         R_SaveTextureDDSFile(skinframe->fog, va("dds/%s_mask.dds", skinframe->basename), true, true);
5800         }
5801
5802         if (r_loaddds)
5803         {
5804                 mymiplevel = savemiplevel;
5805                 if (r_loadnormalmap)
5806                         skinframe->nmap = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_norm.dds", skinframe->basename), (TEXF_ALPHA | textureflags) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP), NULL, NULL, mymiplevel);
5807                 skinframe->glow = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_glow.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
5808                 if (r_loadgloss)
5809                         skinframe->gloss = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_gloss.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
5810                 skinframe->pants = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_pants.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
5811                 skinframe->shirt = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_shirt.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
5812                 skinframe->reflect = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_reflect.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
5813         }
5814
5815         // _norm is the name used by tenebrae and has been adopted as standard
5816         if (r_loadnormalmap && skinframe->nmap == NULL)
5817         {
5818                 mymiplevel = savemiplevel;
5819                 if ((pixels = loadimagepixelsbgra(va("%s_norm", skinframe->basename), false, false, false, &mymiplevel)) != NULL)
5820                 {
5821                         skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | textureflags) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
5822                         Mem_Free(pixels);
5823                         pixels = NULL;
5824                 }
5825                 else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixelsbgra(va("%s_bump", skinframe->basename), false, false, false, &mymiplevel)) != NULL)
5826                 {
5827                         pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
5828                         Image_HeightmapToNormalmap_BGRA(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value);
5829                         skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | textureflags) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
5830                         Mem_Free(pixels);
5831                         Mem_Free(bumppixels);
5832                 }
5833                 else if (r_shadow_bumpscale_basetexture.value > 0)
5834                 {
5835                         pixels = (unsigned char *)Mem_Alloc(tempmempool, basepixels_width * basepixels_height * 4);
5836                         Image_HeightmapToNormalmap_BGRA(basepixels, pixels, basepixels_width, basepixels_height, false, r_shadow_bumpscale_basetexture.value);
5837                         skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), basepixels_width, basepixels_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | textureflags) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
5838                         Mem_Free(pixels);
5839                 }
5840                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->nmap)
5841                         R_SaveTextureDDSFile(skinframe->nmap, va("dds/%s_norm.dds", skinframe->basename), true, true);
5842         }
5843
5844         // _luma is supported only for tenebrae compatibility
5845         // _glow is the preferred name
5846         mymiplevel = savemiplevel;
5847         if (skinframe->glow == NULL && ((pixels = loadimagepixelsbgra(va("%s_glow",  skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel)) || (pixels = loadimagepixelsbgra(va("%s_luma", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel))))
5848         {
5849                 skinframe->glow = R_LoadTexture2D (r_main_texturepool, va("%s_glow", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_glow.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
5850                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->glow)
5851                         R_SaveTextureDDSFile(skinframe->glow, va("dds/%s_glow.dds", skinframe->basename), true, true);
5852                 Mem_Free(pixels);pixels = NULL;
5853         }
5854
5855         mymiplevel = savemiplevel;
5856         if (skinframe->gloss == NULL && r_loadgloss && (pixels = loadimagepixelsbgra(va("%s_gloss", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel)))
5857         {
5858                 skinframe->gloss = R_LoadTexture2D (r_main_texturepool, va("%s_gloss", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_gloss.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
5859                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->gloss)
5860                         R_SaveTextureDDSFile(skinframe->gloss, va("dds/%s_gloss.dds", skinframe->basename), true, true);
5861                 Mem_Free(pixels);
5862                 pixels = NULL;
5863         }
5864
5865         mymiplevel = savemiplevel;
5866         if (skinframe->pants == NULL && (pixels = loadimagepixelsbgra(va("%s_pants", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel)))
5867         {
5868                 skinframe->pants = R_LoadTexture2D (r_main_texturepool, va("%s_pants", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
5869                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->pants)
5870                         R_SaveTextureDDSFile(skinframe->pants, va("dds/%s_pants.dds", skinframe->basename), true, false);
5871                 Mem_Free(pixels);
5872                 pixels = NULL;
5873         }
5874
5875         mymiplevel = savemiplevel;
5876         if (skinframe->shirt == NULL && (pixels = loadimagepixelsbgra(va("%s_shirt", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel)))
5877         {
5878                 skinframe->shirt = R_LoadTexture2D (r_main_texturepool, va("%s_shirt", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
5879                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->shirt)
5880                         R_SaveTextureDDSFile(skinframe->shirt, va("dds/%s_shirt.dds", skinframe->basename), true, false);
5881                 Mem_Free(pixels);
5882                 pixels = NULL;
5883         }
5884
5885         mymiplevel = savemiplevel;
5886         if (skinframe->reflect == NULL && (pixels = loadimagepixelsbgra(va("%s_reflect", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel)))
5887         {
5888                 skinframe->reflect = R_LoadTexture2D (r_main_texturepool, va("%s_reflect", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_reflectmask.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
5889                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->reflect)
5890                         R_SaveTextureDDSFile(skinframe->reflect, va("dds/%s_reflect.dds", skinframe->basename), true, true);
5891                 Mem_Free(pixels);
5892                 pixels = NULL;
5893         }
5894
5895         if (basepixels)
5896                 Mem_Free(basepixels);
5897
5898         return skinframe;
5899 }
5900
5901 // this is only used by .spr32 sprites, HL .spr files, HL .bsp files
5902 skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, const unsigned char *skindata, int width, int height)
5903 {
5904         int i;
5905         unsigned char *temp1, *temp2;
5906         skinframe_t *skinframe;
5907
5908         if (cls.state == ca_dedicated)
5909                 return NULL;
5910
5911         // if already loaded just return it, otherwise make a new skinframe
5912         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height*4) : 0, true);
5913         if (skinframe && skinframe->base)
5914                 return skinframe;
5915
5916         skinframe->stain = NULL;
5917         skinframe->merged = NULL;
5918         skinframe->base = NULL;
5919         skinframe->pants = NULL;
5920         skinframe->shirt = NULL;
5921         skinframe->nmap = NULL;
5922         skinframe->gloss = NULL;
5923         skinframe->glow = NULL;
5924         skinframe->fog = NULL;
5925         skinframe->reflect = NULL;
5926         skinframe->hasalpha = false;
5927
5928         // if no data was provided, then clearly the caller wanted to get a blank skinframe
5929         if (!skindata)
5930                 return NULL;
5931
5932         if (developer_loading.integer)
5933                 Con_Printf("loading 32bit skin \"%s\"\n", name);
5934
5935         if (r_loadnormalmap && r_shadow_bumpscale_basetexture.value > 0)
5936         {
5937                 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
5938                 temp2 = temp1 + width * height * 4;
5939                 Image_HeightmapToNormalmap_BGRA(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
5940                 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, (textureflags | TEXF_ALPHA) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP), -1, NULL);
5941                 Mem_Free(temp1);
5942         }
5943         skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_BGRA, textureflags, -1, NULL);
5944         if (textureflags & TEXF_ALPHA)
5945         {
5946                 for (i = 3;i < width * height * 4;i += 4)
5947                 {
5948                         if (skindata[i] < 255)
5949                         {
5950                                 skinframe->hasalpha = true;
5951                                 break;
5952                         }
5953                 }
5954                 if (r_loadfog && skinframe->hasalpha)
5955                 {
5956                         unsigned char *fogpixels = (unsigned char *)Mem_Alloc(tempmempool, width * height * 4);
5957                         memcpy(fogpixels, skindata, width * height * 4);
5958                         for (i = 0;i < width * height * 4;i += 4)
5959                                 fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
5960                         skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_BGRA, textureflags, -1, NULL);
5961                         Mem_Free(fogpixels);
5962                 }
5963         }
5964
5965         R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, skindata[4 * pix + comp]);
5966         //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]);
5967
5968         return skinframe;
5969 }
5970
5971 skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height)
5972 {
5973         int i;
5974         int featuresmask;
5975         skinframe_t *skinframe;
5976
5977         if (cls.state == ca_dedicated)
5978                 return NULL;
5979
5980         // if already loaded just return it, otherwise make a new skinframe
5981         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
5982         if (skinframe && skinframe->base)
5983                 return skinframe;
5984
5985         skinframe->stain = NULL;
5986         skinframe->merged = NULL;
5987         skinframe->base = NULL;
5988         skinframe->pants = NULL;
5989         skinframe->shirt = NULL;
5990         skinframe->nmap = NULL;
5991         skinframe->gloss = NULL;
5992         skinframe->glow = NULL;
5993         skinframe->fog = NULL;
5994         skinframe->reflect = NULL;
5995         skinframe->hasalpha = false;
5996
5997         // if no data was provided, then clearly the caller wanted to get a blank skinframe
5998         if (!skindata)
5999                 return NULL;
6000
6001         if (developer_loading.integer)
6002                 Con_Printf("loading quake skin \"%s\"\n", name);
6003
6004         // 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)
6005         skinframe->qpixels = Mem_Alloc(r_main_mempool, width*height);
6006         memcpy(skinframe->qpixels, skindata, width*height);
6007         skinframe->qwidth = width;
6008         skinframe->qheight = height;
6009
6010         featuresmask = 0;
6011         for (i = 0;i < width * height;i++)
6012                 featuresmask |= palette_featureflags[skindata[i]];
6013
6014         skinframe->hasalpha = false;
6015         skinframe->qhascolormapping = loadpantsandshirt && (featuresmask & (PALETTEFEATURE_PANTS | PALETTEFEATURE_SHIRT));
6016         skinframe->qgeneratenmap = r_shadow_bumpscale_basetexture.value > 0;
6017         skinframe->qgeneratemerged = true;
6018         skinframe->qgeneratebase = skinframe->qhascolormapping;
6019         skinframe->qgenerateglow = loadglowtexture && (featuresmask & PALETTEFEATURE_GLOW);
6020
6021         R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette_bgra_complete)[skindata[pix]*4 + comp]);
6022         //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]);
6023
6024         return skinframe;
6025 }
6026
6027 static void R_SkinFrame_GenerateTexturesFromQPixels(skinframe_t *skinframe, qboolean colormapped)
6028 {
6029         int width;
6030         int height;
6031         unsigned char *skindata;
6032
6033         if (!skinframe->qpixels)
6034                 return;
6035
6036         if (!skinframe->qhascolormapping)
6037                 colormapped = false;
6038
6039         if (colormapped)
6040         {
6041                 if (!skinframe->qgeneratebase)
6042                         return;
6043         }
6044         else
6045         {
6046                 if (!skinframe->qgeneratemerged)
6047                         return;
6048         }
6049
6050         width = skinframe->qwidth;
6051         height = skinframe->qheight;
6052         skindata = skinframe->qpixels;
6053
6054         if (skinframe->qgeneratenmap)
6055         {
6056                 unsigned char *temp1, *temp2;
6057                 skinframe->qgeneratenmap = false;
6058                 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
6059                 temp2 = temp1 + width * height * 4;
6060                 // use either a custom palette or the quake palette
6061                 Image_Copy8bitBGRA(skindata, temp1, width * height, palette_bgra_complete);
6062                 Image_HeightmapToNormalmap_BGRA(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
6063                 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, (skinframe->textureflags | TEXF_ALPHA) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP), -1, NULL);
6064                 Mem_Free(temp1);
6065         }
6066
6067         if (skinframe->qgenerateglow)
6068         {
6069                 skinframe->qgenerateglow = false;
6070                 skinframe->glow = R_LoadTexture2D(r_main_texturepool, va("%s_glow", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, palette_bgra_onlyfullbrights); // glow
6071         }
6072
6073         if (colormapped)
6074         {
6075                 skinframe->qgeneratebase = false;
6076                 skinframe->base  = R_LoadTexture2D(r_main_texturepool, va("%s_nospecial", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, skinframe->glow ? palette_bgra_nocolormapnofullbrights : palette_bgra_nocolormap);
6077                 skinframe->pants = R_LoadTexture2D(r_main_texturepool, va("%s_pants", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, palette_bgra_pantsaswhite);
6078                 skinframe->shirt = R_LoadTexture2D(r_main_texturepool, va("%s_shirt", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, palette_bgra_shirtaswhite);
6079         }
6080         else
6081         {
6082                 skinframe->qgeneratemerged = false;
6083                 skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, skinframe->glow ? palette_bgra_nofullbrights : palette_bgra_complete);
6084         }
6085
6086         if (!skinframe->qgeneratemerged && !skinframe->qgeneratebase)
6087         {
6088                 Mem_Free(skinframe->qpixels);
6089                 skinframe->qpixels = NULL;
6090         }
6091 }
6092
6093 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)
6094 {
6095         int i;
6096         skinframe_t *skinframe;
6097
6098         if (cls.state == ca_dedicated)
6099                 return NULL;
6100
6101         // if already loaded just return it, otherwise make a new skinframe
6102         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
6103         if (skinframe && skinframe->base)
6104                 return skinframe;
6105
6106         skinframe->stain = NULL;
6107         skinframe->merged = NULL;
6108         skinframe->base = NULL;
6109         skinframe->pants = NULL;
6110         skinframe->shirt = NULL;
6111         skinframe->nmap = NULL;
6112         skinframe->gloss = NULL;
6113         skinframe->glow = NULL;
6114         skinframe->fog = NULL;
6115         skinframe->reflect = NULL;
6116         skinframe->hasalpha = false;
6117
6118         // if no data was provided, then clearly the caller wanted to get a blank skinframe
6119         if (!skindata)
6120                 return NULL;
6121
6122         if (developer_loading.integer)
6123                 Con_Printf("loading embedded 8bit image \"%s\"\n", name);
6124
6125         skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_PALETTE, textureflags, -1, palette);
6126         if (textureflags & TEXF_ALPHA)
6127         {
6128                 for (i = 0;i < width * height;i++)
6129                 {
6130                         if (((unsigned char *)palette)[skindata[i]*4+3] < 255)
6131                         {
6132                                 skinframe->hasalpha = true;
6133                                 break;
6134                         }
6135                 }
6136                 if (r_loadfog && skinframe->hasalpha)
6137                         skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, textureflags, -1, alphapalette);
6138         }
6139
6140         R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette)[skindata[pix]*4 + comp]);
6141         //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]);
6142
6143         return skinframe;
6144 }
6145
6146 skinframe_t *R_SkinFrame_LoadMissing(void)
6147 {
6148         skinframe_t *skinframe;
6149
6150         if (cls.state == ca_dedicated)
6151                 return NULL;
6152
6153         skinframe = R_SkinFrame_Find("missing", TEXF_FORCENEAREST, 0, 0, 0, true);
6154         skinframe->stain = NULL;
6155         skinframe->merged = NULL;
6156         skinframe->base = NULL;
6157         skinframe->pants = NULL;
6158         skinframe->shirt = NULL;
6159         skinframe->nmap = NULL;
6160         skinframe->gloss = NULL;
6161         skinframe->glow = NULL;
6162         skinframe->fog = NULL;
6163         skinframe->reflect = NULL;
6164         skinframe->hasalpha = false;
6165
6166         skinframe->avgcolor[0] = rand() / RAND_MAX;
6167         skinframe->avgcolor[1] = rand() / RAND_MAX;
6168         skinframe->avgcolor[2] = rand() / RAND_MAX;
6169         skinframe->avgcolor[3] = 1;
6170
6171         return skinframe;
6172 }
6173
6174 //static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"};
6175 typedef struct suffixinfo_s
6176 {
6177         char *suffix;
6178         qboolean flipx, flipy, flipdiagonal;
6179 }
6180 suffixinfo_t;
6181 static suffixinfo_t suffix[3][6] =
6182 {
6183         {
6184                 {"px",   false, false, false},
6185                 {"nx",   false, false, false},
6186                 {"py",   false, false, false},
6187                 {"ny",   false, false, false},
6188                 {"pz",   false, false, false},
6189                 {"nz",   false, false, false}
6190         },
6191         {
6192                 {"posx", false, false, false},
6193                 {"negx", false, false, false},
6194                 {"posy", false, false, false},
6195                 {"negy", false, false, false},
6196                 {"posz", false, false, false},
6197                 {"negz", false, false, false}
6198         },
6199         {
6200                 {"rt",    true, false,  true},
6201                 {"lf",   false,  true,  true},
6202                 {"ft",    true,  true, false},
6203                 {"bk",   false, false, false},
6204                 {"up",    true, false,  true},
6205                 {"dn",    true, false,  true}
6206         }
6207 };
6208
6209 static int componentorder[4] = {0, 1, 2, 3};
6210
6211 rtexture_t *R_LoadCubemap(const char *basename)
6212 {
6213         int i, j, cubemapsize;
6214         unsigned char *cubemappixels, *image_buffer;
6215         rtexture_t *cubemaptexture;
6216         char name[256];
6217         // must start 0 so the first loadimagepixels has no requested width/height
6218         cubemapsize = 0;
6219         cubemappixels = NULL;
6220         cubemaptexture = NULL;
6221         // keep trying different suffix groups (posx, px, rt) until one loads
6222         for (j = 0;j < 3 && !cubemappixels;j++)
6223         {
6224                 // load the 6 images in the suffix group
6225                 for (i = 0;i < 6;i++)
6226                 {
6227                         // generate an image name based on the base and and suffix
6228                         dpsnprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix);
6229                         // load it
6230                         if ((image_buffer = loadimagepixelsbgra(name, false, false, r_texture_convertsRGB_cubemap.integer, NULL)))
6231                         {
6232                                 // an image loaded, make sure width and height are equal
6233                                 if (image_width == image_height && (!cubemappixels || image_width == cubemapsize))
6234                                 {
6235                                         // if this is the first image to load successfully, allocate the cubemap memory
6236                                         if (!cubemappixels && image_width >= 1)
6237                                         {
6238                                                 cubemapsize = image_width;
6239                                                 // note this clears to black, so unavailable sides are black
6240                                                 cubemappixels = (unsigned char *)Mem_Alloc(tempmempool, 6*cubemapsize*cubemapsize*4);
6241                                         }
6242                                         // copy the image with any flipping needed by the suffix (px and posx types don't need flipping)
6243                                         if (cubemappixels)
6244                                                 Image_CopyMux(cubemappixels+i*cubemapsize*cubemapsize*4, image_buffer, cubemapsize, cubemapsize, suffix[j][i].flipx, suffix[j][i].flipy, suffix[j][i].flipdiagonal, 4, 4, componentorder);
6245                                 }
6246                                 else
6247                                         Con_Printf("Cubemap image \"%s\" (%ix%i) is not square, OpenGL requires square cubemaps.\n", name, image_width, image_height);
6248                                 // free the image
6249                                 Mem_Free(image_buffer);
6250                         }
6251                 }
6252         }
6253         // if a cubemap loaded, upload it
6254         if (cubemappixels)
6255         {
6256                 if (developer_loading.integer)
6257                         Con_Printf("loading cubemap \"%s\"\n", basename);
6258
6259                 cubemaptexture = R_LoadTextureCubeMap(r_main_texturepool, basename, cubemapsize, cubemappixels, TEXTYPE_BGRA, (gl_texturecompression_lightcubemaps.integer ? TEXF_COMPRESS : 0) | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
6260                 Mem_Free(cubemappixels);
6261         }
6262         else
6263         {
6264                 Con_DPrintf("failed to load cubemap \"%s\"\n", basename);
6265                 if (developer_loading.integer)
6266                 {
6267                         Con_Printf("(tried tried images ");
6268                         for (j = 0;j < 3;j++)
6269                                 for (i = 0;i < 6;i++)
6270                                         Con_Printf("%s\"%s%s.tga\"", j + i > 0 ? ", " : "", basename, suffix[j][i].suffix);
6271                         Con_Print(" and was unable to find any of them).\n");
6272                 }
6273         }
6274         return cubemaptexture;
6275 }
6276
6277 rtexture_t *R_GetCubemap(const char *basename)
6278 {
6279         int i;
6280         for (i = 0;i < r_texture_numcubemaps;i++)
6281                 if (!strcasecmp(r_texture_cubemaps[i].basename, basename))
6282                         return r_texture_cubemaps[i].texture ? r_texture_cubemaps[i].texture : r_texture_whitecube;
6283         if (i >= MAX_CUBEMAPS)
6284                 return r_texture_whitecube;
6285         r_texture_numcubemaps++;
6286         strlcpy(r_texture_cubemaps[i].basename, basename, sizeof(r_texture_cubemaps[i].basename));
6287         r_texture_cubemaps[i].texture = R_LoadCubemap(r_texture_cubemaps[i].basename);
6288         return r_texture_cubemaps[i].texture;
6289 }
6290
6291 void R_FreeCubemaps(void)
6292 {
6293         int i;
6294         for (i = 0;i < r_texture_numcubemaps;i++)
6295         {
6296                 if (developer_loading.integer)
6297                         Con_DPrintf("unloading cubemap \"%s\"\n", r_texture_cubemaps[i].basename);
6298                 if (r_texture_cubemaps[i].texture)
6299                         R_FreeTexture(r_texture_cubemaps[i].texture);
6300         }
6301         r_texture_numcubemaps = 0;
6302 }
6303
6304 void R_Main_FreeViewCache(void)
6305 {
6306         if (r_refdef.viewcache.entityvisible)
6307                 Mem_Free(r_refdef.viewcache.entityvisible);
6308         if (r_refdef.viewcache.world_pvsbits)
6309                 Mem_Free(r_refdef.viewcache.world_pvsbits);
6310         if (r_refdef.viewcache.world_leafvisible)
6311                 Mem_Free(r_refdef.viewcache.world_leafvisible);
6312         if (r_refdef.viewcache.world_surfacevisible)
6313                 Mem_Free(r_refdef.viewcache.world_surfacevisible);
6314         memset(&r_refdef.viewcache, 0, sizeof(r_refdef.viewcache));
6315 }
6316
6317 void R_Main_ResizeViewCache(void)
6318 {
6319         int numentities = r_refdef.scene.numentities;
6320         int numclusters = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_pvsclusters : 1;
6321         int numclusterbytes = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_pvsclusterbytes : 1;
6322         int numleafs = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_leafs : 1;
6323         int numsurfaces = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->num_surfaces : 1;
6324         if (r_refdef.viewcache.maxentities < numentities)
6325         {
6326                 r_refdef.viewcache.maxentities = numentities;
6327                 if (r_refdef.viewcache.entityvisible)
6328                         Mem_Free(r_refdef.viewcache.entityvisible);
6329                 r_refdef.viewcache.entityvisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.maxentities);
6330         }
6331         if (r_refdef.viewcache.world_numclusters != numclusters)
6332         {
6333                 r_refdef.viewcache.world_numclusters = numclusters;
6334                 r_refdef.viewcache.world_numclusterbytes = numclusterbytes;
6335                 if (r_refdef.viewcache.world_pvsbits)
6336                         Mem_Free(r_refdef.viewcache.world_pvsbits);
6337                 r_refdef.viewcache.world_pvsbits = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numclusterbytes);
6338         }
6339         if (r_refdef.viewcache.world_numleafs != numleafs)
6340         {
6341                 r_refdef.viewcache.world_numleafs = numleafs;
6342                 if (r_refdef.viewcache.world_leafvisible)
6343                         Mem_Free(r_refdef.viewcache.world_leafvisible);
6344                 r_refdef.viewcache.world_leafvisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numleafs);
6345         }
6346         if (r_refdef.viewcache.world_numsurfaces != numsurfaces)
6347         {
6348                 r_refdef.viewcache.world_numsurfaces = numsurfaces;
6349                 if (r_refdef.viewcache.world_surfacevisible)
6350                         Mem_Free(r_refdef.viewcache.world_surfacevisible);
6351                 r_refdef.viewcache.world_surfacevisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numsurfaces);
6352         }
6353 }
6354
6355 extern rtexture_t *loadingscreentexture;
6356 void gl_main_start(void)
6357 {
6358         loadingscreentexture = NULL;
6359         r_texture_blanknormalmap = NULL;
6360         r_texture_white = NULL;
6361         r_texture_grey128 = NULL;
6362         r_texture_black = NULL;
6363         r_texture_whitecube = NULL;
6364         r_texture_normalizationcube = NULL;
6365         r_texture_fogattenuation = NULL;
6366         r_texture_fogheighttexture = NULL;
6367         r_texture_gammaramps = NULL;
6368         r_texture_numcubemaps = 0;
6369
6370         r_loaddds = vid.support.arb_texture_compression && vid.support.ext_texture_compression_s3tc && r_texture_dds_load.integer;
6371         r_savedds = vid.support.arb_texture_compression && vid.support.ext_texture_compression_s3tc && r_texture_dds_save.integer;
6372
6373         switch(vid.renderpath)
6374         {
6375         case RENDERPATH_GL20:
6376         case RENDERPATH_CGGL:
6377                 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
6378                 Cvar_SetValueQuick(&gl_combine, 1);
6379                 Cvar_SetValueQuick(&r_glsl, 1);
6380                 r_loadnormalmap = true;
6381                 r_loadgloss = true;
6382                 r_loadfog = false;
6383                 break;
6384         case RENDERPATH_GL13:
6385                 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
6386                 Cvar_SetValueQuick(&gl_combine, 1);
6387                 Cvar_SetValueQuick(&r_glsl, 0);
6388                 r_loadnormalmap = false;
6389                 r_loadgloss = false;
6390                 r_loadfog = true;
6391                 break;
6392         case RENDERPATH_GL11:
6393                 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
6394                 Cvar_SetValueQuick(&gl_combine, 0);
6395                 Cvar_SetValueQuick(&r_glsl, 0);
6396                 r_loadnormalmap = false;
6397                 r_loadgloss = false;
6398                 r_loadfog = true;
6399                 break;
6400         }
6401
6402         R_AnimCache_Free();
6403         R_FrameData_Reset();
6404
6405         r_numqueries = 0;
6406         r_maxqueries = 0;
6407         memset(r_queries, 0, sizeof(r_queries));
6408
6409         r_qwskincache = NULL;
6410         r_qwskincache_size = 0;
6411
6412         // set up r_skinframe loading system for textures
6413         memset(&r_skinframe, 0, sizeof(r_skinframe));
6414         r_skinframe.loadsequence = 1;
6415         Mem_ExpandableArray_NewArray(&r_skinframe.array, r_main_mempool, sizeof(skinframe_t), 256);
6416
6417         r_main_texturepool = R_AllocTexturePool();
6418         R_BuildBlankTextures();
6419         R_BuildNoTexture();
6420         if (vid.support.arb_texture_cube_map)
6421         {
6422                 R_BuildWhiteCube();
6423                 R_BuildNormalizationCube();
6424         }
6425         r_texture_fogattenuation = NULL;
6426         r_texture_fogheighttexture = NULL;
6427         r_texture_gammaramps = NULL;
6428         //r_texture_fogintensity = NULL;
6429         memset(&r_bloomstate, 0, sizeof(r_bloomstate));
6430         memset(&r_waterstate, 0, sizeof(r_waterstate));
6431         r_glsl_permutation = NULL;
6432         memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
6433         Mem_ExpandableArray_NewArray(&r_glsl_permutationarray, r_main_mempool, sizeof(r_glsl_permutation_t), 256);
6434         glslshaderstring = NULL;
6435 #ifdef SUPPORTCG
6436         r_cg_permutation = NULL;
6437         memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash));
6438         Mem_ExpandableArray_NewArray(&r_cg_permutationarray, r_main_mempool, sizeof(r_cg_permutation_t), 256);
6439         cgshaderstring = NULL;
6440 #endif
6441         memset(&r_svbsp, 0, sizeof (r_svbsp));
6442
6443         r_refdef.fogmasktable_density = 0;
6444 }
6445
6446 void gl_main_shutdown(void)
6447 {
6448         R_AnimCache_Free();
6449         R_FrameData_Reset();
6450
6451         R_Main_FreeViewCache();
6452
6453         if (r_maxqueries)
6454                 qglDeleteQueriesARB(r_maxqueries, r_queries);
6455
6456         r_numqueries = 0;
6457         r_maxqueries = 0;
6458         memset(r_queries, 0, sizeof(r_queries));
6459
6460         r_qwskincache = NULL;
6461         r_qwskincache_size = 0;
6462
6463         // clear out the r_skinframe state
6464         Mem_ExpandableArray_FreeArray(&r_skinframe.array);
6465         memset(&r_skinframe, 0, sizeof(r_skinframe));
6466
6467         if (r_svbsp.nodes)
6468                 Mem_Free(r_svbsp.nodes);
6469         memset(&r_svbsp, 0, sizeof (r_svbsp));
6470         R_FreeTexturePool(&r_main_texturepool);
6471         loadingscreentexture = NULL;
6472         r_texture_blanknormalmap = NULL;
6473         r_texture_white = NULL;
6474         r_texture_grey128 = NULL;
6475         r_texture_black = NULL;
6476         r_texture_whitecube = NULL;
6477         r_texture_normalizationcube = NULL;
6478         r_texture_fogattenuation = NULL;
6479         r_texture_fogheighttexture = NULL;
6480         r_texture_gammaramps = NULL;
6481         r_texture_numcubemaps = 0;
6482         //r_texture_fogintensity = NULL;
6483         memset(&r_bloomstate, 0, sizeof(r_bloomstate));
6484         memset(&r_waterstate, 0, sizeof(r_waterstate));
6485         r_glsl_permutation = NULL;
6486         memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
6487         glslshaderstring = NULL;
6488 #ifdef SUPPORTCG
6489         r_cg_permutation = NULL;
6490         memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash));
6491         cgshaderstring = NULL;
6492 #endif
6493         R_GLSL_Restart_f();
6494 }
6495
6496 extern void CL_ParseEntityLump(char *entitystring);
6497 void gl_main_newmap(void)
6498 {
6499         // FIXME: move this code to client
6500         char *entities, entname[MAX_QPATH];
6501         if (r_qwskincache)
6502                 Mem_Free(r_qwskincache);
6503         r_qwskincache = NULL;
6504         r_qwskincache_size = 0;
6505         if (cl.worldmodel)
6506         {
6507                 dpsnprintf(entname, sizeof(entname), "%s.ent", cl.worldnamenoextension);
6508                 if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
6509                 {
6510                         CL_ParseEntityLump(entities);
6511                         Mem_Free(entities);
6512                         return;
6513                 }
6514                 if (cl.worldmodel->brush.entities)
6515                         CL_ParseEntityLump(cl.worldmodel->brush.entities);
6516         }
6517         R_Main_FreeViewCache();
6518
6519         R_FrameData_Reset();
6520 }
6521
6522 void GL_Main_Init(void)
6523 {
6524         r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
6525
6526         Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed");
6527         Cmd_AddCommand("r_glsl_dumpshader", R_GLSL_DumpShader_f, "dumps the engine internal default.glsl shader into glsl/default.glsl");
6528         // FIXME: the client should set up r_refdef.fog stuff including the fogmasktable
6529         if (gamemode == GAME_NEHAHRA)
6530         {
6531                 Cvar_RegisterVariable (&gl_fogenable);
6532                 Cvar_RegisterVariable (&gl_fogdensity);
6533                 Cvar_RegisterVariable (&gl_fogred);
6534                 Cvar_RegisterVariable (&gl_foggreen);
6535                 Cvar_RegisterVariable (&gl_fogblue);
6536                 Cvar_RegisterVariable (&gl_fogstart);
6537                 Cvar_RegisterVariable (&gl_fogend);
6538                 Cvar_RegisterVariable (&gl_skyclip);
6539         }
6540         Cvar_RegisterVariable(&r_motionblur);
6541         Cvar_RegisterVariable(&r_motionblur_maxblur);
6542         Cvar_RegisterVariable(&r_motionblur_bmin);
6543         Cvar_RegisterVariable(&r_motionblur_vmin);
6544         Cvar_RegisterVariable(&r_motionblur_vmax);
6545         Cvar_RegisterVariable(&r_motionblur_vcoeff);
6546         Cvar_RegisterVariable(&r_motionblur_randomize);
6547         Cvar_RegisterVariable(&r_damageblur);
6548         Cvar_RegisterVariable(&r_equalize_entities_fullbright);
6549         Cvar_RegisterVariable(&r_equalize_entities_minambient);
6550         Cvar_RegisterVariable(&r_equalize_entities_by);
6551         Cvar_RegisterVariable(&r_equalize_entities_to);
6552         Cvar_RegisterVariable(&r_depthfirst);
6553         Cvar_RegisterVariable(&r_useinfinitefarclip);
6554         Cvar_RegisterVariable(&r_farclip_base);
6555         Cvar_RegisterVariable(&r_farclip_world);
6556         Cvar_RegisterVariable(&r_nearclip);
6557         Cvar_RegisterVariable(&r_showbboxes);
6558         Cvar_RegisterVariable(&r_showsurfaces);
6559         Cvar_RegisterVariable(&r_showtris);
6560         Cvar_RegisterVariable(&r_shownormals);
6561         Cvar_RegisterVariable(&r_showlighting);
6562         Cvar_RegisterVariable(&r_showshadowvolumes);
6563         Cvar_RegisterVariable(&r_showcollisionbrushes);
6564         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
6565         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
6566         Cvar_RegisterVariable(&r_showdisabledepthtest);
6567         Cvar_RegisterVariable(&r_drawportals);
6568         Cvar_RegisterVariable(&r_drawentities);
6569         Cvar_RegisterVariable(&r_draw2d);
6570         Cvar_RegisterVariable(&r_drawworld);
6571         Cvar_RegisterVariable(&r_cullentities_trace);
6572         Cvar_RegisterVariable(&r_cullentities_trace_samples);
6573         Cvar_RegisterVariable(&r_cullentities_trace_tempentitysamples);
6574         Cvar_RegisterVariable(&r_cullentities_trace_enlarge);
6575         Cvar_RegisterVariable(&r_cullentities_trace_delay);
6576         Cvar_RegisterVariable(&r_drawviewmodel);
6577         Cvar_RegisterVariable(&r_drawexteriormodel);
6578         Cvar_RegisterVariable(&r_speeds);
6579         Cvar_RegisterVariable(&r_fullbrights);
6580         Cvar_RegisterVariable(&r_wateralpha);
6581         Cvar_RegisterVariable(&r_dynamic);
6582         Cvar_RegisterVariable(&r_fullbright);
6583         Cvar_RegisterVariable(&r_shadows);
6584         Cvar_RegisterVariable(&r_shadows_darken);
6585         Cvar_RegisterVariable(&r_shadows_drawafterrtlighting);
6586         Cvar_RegisterVariable(&r_shadows_castfrombmodels);
6587         Cvar_RegisterVariable(&r_shadows_throwdistance);
6588         Cvar_RegisterVariable(&r_shadows_throwdirection);
6589         Cvar_RegisterVariable(&r_shadows_focus);
6590         Cvar_RegisterVariable(&r_shadows_shadowmapscale);
6591         Cvar_RegisterVariable(&r_q1bsp_skymasking);
6592         Cvar_RegisterVariable(&r_polygonoffset_submodel_factor);
6593         Cvar_RegisterVariable(&r_polygonoffset_submodel_offset);
6594         Cvar_RegisterVariable(&r_polygonoffset_decals_factor);
6595         Cvar_RegisterVariable(&r_polygonoffset_decals_offset);
6596         Cvar_RegisterVariable(&r_fog_exp2);
6597         Cvar_RegisterVariable(&r_drawfog);
6598         Cvar_RegisterVariable(&r_transparentdepthmasking);
6599         Cvar_RegisterVariable(&r_texture_dds_load);
6600         Cvar_RegisterVariable(&r_texture_dds_save);
6601         Cvar_RegisterVariable(&r_texture_convertsRGB_2d);
6602         Cvar_RegisterVariable(&r_texture_convertsRGB_skin);
6603         Cvar_RegisterVariable(&r_texture_convertsRGB_cubemap);
6604         Cvar_RegisterVariable(&r_texture_convertsRGB_skybox);
6605         Cvar_RegisterVariable(&r_texture_convertsRGB_particles);
6606         Cvar_RegisterVariable(&r_textureunits);
6607         Cvar_RegisterVariable(&gl_combine);
6608         Cvar_RegisterVariable(&r_glsl);
6609         Cvar_RegisterVariable(&r_glsl_deluxemapping);
6610         Cvar_RegisterVariable(&r_glsl_offsetmapping);
6611         Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
6612         Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
6613         Cvar_RegisterVariable(&r_glsl_postprocess);
6614         Cvar_RegisterVariable(&r_glsl_postprocess_uservec1);
6615         Cvar_RegisterVariable(&r_glsl_postprocess_uservec2);
6616         Cvar_RegisterVariable(&r_glsl_postprocess_uservec3);
6617         Cvar_RegisterVariable(&r_glsl_postprocess_uservec4);
6618         Cvar_RegisterVariable(&r_water);
6619         Cvar_RegisterVariable(&r_water_resolutionmultiplier);
6620         Cvar_RegisterVariable(&r_water_clippingplanebias);
6621         Cvar_RegisterVariable(&r_water_refractdistort);
6622         Cvar_RegisterVariable(&r_water_reflectdistort);
6623         Cvar_RegisterVariable(&r_lerpsprites);
6624         Cvar_RegisterVariable(&r_lerpmodels);
6625         Cvar_RegisterVariable(&r_lerplightstyles);
6626         Cvar_RegisterVariable(&r_waterscroll);
6627         Cvar_RegisterVariable(&r_bloom);
6628         Cvar_RegisterVariable(&r_bloom_colorscale);
6629         Cvar_RegisterVariable(&r_bloom_brighten);
6630         Cvar_RegisterVariable(&r_bloom_blur);
6631         Cvar_RegisterVariable(&r_bloom_resolution);
6632         Cvar_RegisterVariable(&r_bloom_colorexponent);
6633         Cvar_RegisterVariable(&r_bloom_colorsubtract);
6634         Cvar_RegisterVariable(&r_hdr);
6635         Cvar_RegisterVariable(&r_hdr_scenebrightness);
6636         Cvar_RegisterVariable(&r_hdr_glowintensity);
6637         Cvar_RegisterVariable(&r_hdr_range);
6638         Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
6639         Cvar_RegisterVariable(&developer_texturelogging);
6640         Cvar_RegisterVariable(&gl_lightmaps);
6641         Cvar_RegisterVariable(&r_test);
6642         Cvar_RegisterVariable(&r_batchmode);
6643         Cvar_RegisterVariable(&r_glsl_saturation);
6644         Cvar_RegisterVariable(&r_framedatasize);
6645         if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
6646                 Cvar_SetValue("r_fullbrights", 0);
6647         R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap, NULL, NULL);
6648
6649         Cvar_RegisterVariable(&r_track_sprites);
6650         Cvar_RegisterVariable(&r_track_sprites_flags);
6651         Cvar_RegisterVariable(&r_track_sprites_scalew);
6652         Cvar_RegisterVariable(&r_track_sprites_scaleh);
6653         Cvar_RegisterVariable(&r_overheadsprites_perspective);
6654         Cvar_RegisterVariable(&r_overheadsprites_pushback);
6655 }
6656
6657 extern void R_Textures_Init(void);
6658 extern void GL_Draw_Init(void);
6659 extern void GL_Main_Init(void);
6660 extern void R_Shadow_Init(void);
6661 extern void R_Sky_Init(void);
6662 extern void GL_Surf_Init(void);
6663 extern void R_Particles_Init(void);
6664 extern void R_Explosion_Init(void);
6665 extern void gl_backend_init(void);
6666 extern void Sbar_Init(void);
6667 extern void R_LightningBeams_Init(void);
6668 extern void Mod_RenderInit(void);
6669 extern void Font_Init(void);
6670
6671 void Render_Init(void)
6672 {
6673         gl_backend_init();
6674         R_Textures_Init();
6675         GL_Main_Init();
6676         Font_Init();
6677         GL_Draw_Init();
6678         R_Shadow_Init();
6679         R_Sky_Init();
6680         GL_Surf_Init();
6681         Sbar_Init();
6682         R_Particles_Init();
6683         R_Explosion_Init();
6684         R_LightningBeams_Init();
6685         Mod_RenderInit();
6686 }
6687
6688 /*
6689 ===============
6690 GL_Init
6691 ===============
6692 */
6693 extern char *ENGINE_EXTENSIONS;
6694 void GL_Init (void)
6695 {
6696         gl_renderer = (const char *)qglGetString(GL_RENDERER);
6697         gl_vendor = (const char *)qglGetString(GL_VENDOR);
6698         gl_version = (const char *)qglGetString(GL_VERSION);
6699         gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
6700
6701         if (!gl_extensions)
6702                 gl_extensions = "";
6703         if (!gl_platformextensions)
6704                 gl_platformextensions = "";
6705
6706         Con_Printf("GL_VENDOR: %s\n", gl_vendor);
6707         Con_Printf("GL_RENDERER: %s\n", gl_renderer);
6708         Con_Printf("GL_VERSION: %s\n", gl_version);
6709         Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
6710         Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
6711
6712         VID_CheckExtensions();
6713
6714         // LordHavoc: report supported extensions
6715         Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
6716
6717         // clear to black (loading plaque will be seen over this)
6718         CHECKGLERROR
6719         qglClearColor(0,0,0,1);CHECKGLERROR
6720         qglClear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
6721 }
6722
6723 int R_CullBox(const vec3_t mins, const vec3_t maxs)
6724 {
6725         int i;
6726         mplane_t *p;
6727         for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
6728         {
6729                 // skip nearclip plane, it often culls portals when you are very close, and is almost never useful
6730                 if (i == 4)
6731                         continue;
6732                 p = r_refdef.view.frustum + i;
6733                 switch(p->signbits)
6734                 {
6735                 default:
6736                 case 0:
6737                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
6738                                 return true;
6739                         break;
6740                 case 1:
6741                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
6742                                 return true;
6743                         break;
6744                 case 2:
6745                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
6746                                 return true;
6747                         break;
6748                 case 3:
6749                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
6750                                 return true;
6751                         break;
6752                 case 4:
6753                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
6754                                 return true;
6755                         break;
6756                 case 5:
6757                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
6758                                 return true;
6759                         break;
6760                 case 6:
6761                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
6762                                 return true;
6763                         break;
6764                 case 7:
6765                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
6766                                 return true;
6767                         break;
6768                 }
6769         }
6770         return false;
6771 }
6772
6773 int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes)
6774 {
6775         int i;
6776         const mplane_t *p;
6777         for (i = 0;i < numplanes;i++)
6778         {
6779                 p = planes + i;
6780                 switch(p->signbits)
6781                 {
6782                 default:
6783                 case 0:
6784                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
6785                                 return true;
6786                         break;
6787                 case 1:
6788                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
6789                                 return true;
6790                         break;
6791                 case 2:
6792                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
6793                                 return true;
6794                         break;
6795                 case 3:
6796                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
6797                                 return true;
6798                         break;
6799                 case 4:
6800                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
6801                                 return true;
6802                         break;
6803                 case 5:
6804                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
6805                                 return true;
6806                         break;
6807                 case 6:
6808                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
6809                                 return true;
6810                         break;
6811                 case 7:
6812                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
6813                                 return true;
6814                         break;
6815                 }
6816         }
6817         return false;
6818 }
6819
6820 //==================================================================================
6821
6822 // LordHavoc: this stores temporary data used within the same frame
6823
6824 qboolean r_framedata_failed;
6825 static size_t r_framedata_size;
6826 static size_t r_framedata_current;
6827 static void *r_framedata_base;
6828
6829 void R_FrameData_Reset(void)
6830 {
6831         if (r_framedata_base)
6832                 Mem_Free(r_framedata_base);
6833         r_framedata_base = NULL;
6834         r_framedata_size = 0;
6835         r_framedata_current = 0;
6836         r_framedata_failed = false;
6837 }
6838
6839 void R_FrameData_NewFrame(void)
6840 {
6841         size_t wantedsize;
6842         if (r_framedata_failed)
6843                 Cvar_SetValueQuick(&r_framedatasize, r_framedatasize.value + 1.0f);
6844         wantedsize = (size_t)(r_framedatasize.value * 1024*1024);
6845         wantedsize = bound(65536, wantedsize, 128*1024*1024);
6846         if (r_framedata_size != wantedsize)
6847         {
6848                 r_framedata_size = wantedsize;
6849                 if (r_framedata_base)
6850                         Mem_Free(r_framedata_base);
6851                 r_framedata_base = Mem_Alloc(r_main_mempool, r_framedata_size);
6852         }
6853         r_framedata_current = 0;
6854         r_framedata_failed = false;
6855 }
6856
6857 void *R_FrameData_Alloc(size_t size)
6858 {
6859         void *data;
6860
6861         // align to 16 byte boundary
6862         size = (size + 15) & ~15;
6863         data = (void *)((unsigned char*)r_framedata_base + r_framedata_current);
6864         r_framedata_current += size;
6865
6866         // check overflow
6867         if (r_framedata_current > r_framedata_size)
6868                 r_framedata_failed = true;
6869
6870         // return NULL on everything after a failure
6871         if (r_framedata_failed)
6872                 return NULL;
6873
6874         return data;
6875 }
6876
6877 void *R_FrameData_Store(size_t size, void *data)
6878 {
6879         void *d = R_FrameData_Alloc(size);
6880         if (d)
6881                 memcpy(d, data, size);
6882         return d;
6883 }
6884
6885 //==================================================================================
6886
6887 // LordHavoc: animcache originally written by Echon, rewritten since then
6888
6889 /**
6890  * Animation cache prevents re-generating mesh data for an animated model
6891  * multiple times in one frame for lighting, shadowing, reflections, etc.
6892  */
6893
6894 void R_AnimCache_Free(void)
6895 {
6896 }
6897
6898 void R_AnimCache_ClearCache(void)
6899 {
6900         int i;
6901         entity_render_t *ent;
6902
6903         for (i = 0;i < r_refdef.scene.numentities;i++)
6904         {
6905                 ent = r_refdef.scene.entities[i];
6906                 ent->animcache_vertex3f = NULL;
6907                 ent->animcache_normal3f = NULL;
6908                 ent->animcache_svector3f = NULL;
6909                 ent->animcache_tvector3f = NULL;
6910         }
6911 }
6912
6913 qboolean R_AnimCache_GetEntity(entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
6914 {
6915         dp_model_t *model = ent->model;
6916         int numvertices;
6917         // see if it's already cached this frame
6918         if (ent->animcache_vertex3f)
6919         {
6920                 // add normals/tangents if needed
6921                 if (wantnormals || wanttangents)
6922                 {
6923                         if (ent->animcache_normal3f)
6924                                 wantnormals = false;
6925                         if (ent->animcache_svector3f)
6926                                 wanttangents = false;
6927                         if (wantnormals || wanttangents)
6928                         {
6929                                 numvertices = model->surfmesh.num_vertices;
6930                                 if (wantnormals)
6931                                         ent->animcache_normal3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
6932                                 if (wanttangents)
6933                                 {
6934                                         ent->animcache_svector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
6935                                         ent->animcache_tvector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
6936                                 }
6937                                 if (!r_framedata_failed)
6938                                         model->AnimateVertices(model, ent->frameblend, ent->skeleton, NULL, wantnormals ? ent->animcache_normal3f : NULL, wanttangents ? ent->animcache_svector3f : NULL, wanttangents ? ent->animcache_tvector3f : NULL);
6939                         }
6940                 }
6941         }
6942         else
6943         {
6944                 // see if this ent is worth caching
6945                 if (!model || !model->Draw || !model->surfmesh.isanimated || !model->AnimateVertices || (ent->frameblend[0].lerp == 1 && ent->frameblend[0].subframe == 0 && !ent->skeleton))
6946                         return false;
6947                 // get some memory for this entity and generate mesh data
6948                 numvertices = model->surfmesh.num_vertices;
6949                 ent->animcache_vertex3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
6950                 if (wantnormals)
6951                         ent->animcache_normal3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
6952                 if (wanttangents)
6953                 {
6954                         ent->animcache_svector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
6955                         ent->animcache_tvector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
6956                 }
6957                 if (!r_framedata_failed)
6958                         model->AnimateVertices(model, ent->frameblend, ent->skeleton, ent->animcache_vertex3f, ent->animcache_normal3f, ent->animcache_svector3f, ent->animcache_tvector3f);
6959         }
6960         return !r_framedata_failed;
6961 }
6962
6963 void R_AnimCache_CacheVisibleEntities(void)
6964 {
6965         int i;
6966         qboolean wantnormals = !r_showsurfaces.integer;
6967         qboolean wanttangents = !r_showsurfaces.integer;
6968
6969         switch(vid.renderpath)
6970         {
6971         case RENDERPATH_GL20:
6972         case RENDERPATH_CGGL:
6973                 break;
6974         case RENDERPATH_GL13:
6975         case RENDERPATH_GL11:
6976                 wanttangents = false;
6977                 break;
6978         }
6979
6980         // TODO: thread this
6981         // NOTE: R_PrepareRTLights() also caches entities
6982
6983         for (i = 0;i < r_refdef.scene.numentities;i++)
6984                 if (r_refdef.viewcache.entityvisible[i])
6985                         R_AnimCache_GetEntity(r_refdef.scene.entities[i], wantnormals, wanttangents);
6986 }
6987
6988 //==================================================================================
6989
6990 static void R_View_UpdateEntityLighting (void)
6991 {
6992         int i;
6993         entity_render_t *ent;
6994         vec3_t tempdiffusenormal, avg;
6995         vec_t f, fa, fd, fdd;
6996         qboolean skipunseen = r_shadows.integer != 1; //|| R_Shadow_ShadowMappingEnabled();
6997
6998         for (i = 0;i < r_refdef.scene.numentities;i++)
6999         {
7000                 ent = r_refdef.scene.entities[i];
7001
7002                 // skip unseen models
7003                 if (!r_refdef.viewcache.entityvisible[i] && skipunseen)
7004                         continue;
7005
7006                 // skip bsp models
7007                 if (ent->model && ent->model->brush.num_leafs)
7008                 {
7009                         // TODO: use modellight for r_ambient settings on world?
7010                         VectorSet(ent->modellight_ambient, 0, 0, 0);
7011                         VectorSet(ent->modellight_diffuse, 0, 0, 0);
7012                         VectorSet(ent->modellight_lightdir, 0, 0, 1);
7013                         continue;
7014                 }
7015
7016                 // fetch the lighting from the worldmodel data
7017                 VectorClear(ent->modellight_ambient);
7018                 VectorClear(ent->modellight_diffuse);
7019                 VectorClear(tempdiffusenormal);
7020                 if ((ent->flags & RENDER_LIGHT) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint)
7021                 {
7022                         vec3_t org;
7023                         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
7024                         r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, org, ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal);
7025                         if(ent->flags & RENDER_EQUALIZE)
7026                         {
7027                                 // first fix up ambient lighting...
7028                                 if(r_equalize_entities_minambient.value > 0)
7029                                 {
7030                                         fd = 0.299f * ent->modellight_diffuse[0] + 0.587f * ent->modellight_diffuse[1] + 0.114f * ent->modellight_diffuse[2];
7031                                         if(fd > 0)
7032                                         {
7033                                                 fa = (0.299f * ent->modellight_ambient[0] + 0.587f * ent->modellight_ambient[1] + 0.114f * ent->modellight_ambient[2]);
7034                                                 if(fa < r_equalize_entities_minambient.value * fd)
7035                                                 {
7036                                                         // solve:
7037                                                         //   fa'/fd' = minambient
7038                                                         //   fa'+0.25*fd' = fa+0.25*fd
7039                                                         //   ...
7040                                                         //   fa' = fd' * minambient
7041                                                         //   fd'*(0.25+minambient) = fa+0.25*fd
7042                                                         //   ...
7043                                                         //   fd' = (fa+0.25*fd) * 1 / (0.25+minambient)
7044                                                         //   fa' = (fa+0.25*fd) * minambient / (0.25+minambient)
7045                                                         //   ...
7046                                                         fdd = (fa + 0.25f * fd) / (0.25f + r_equalize_entities_minambient.value);
7047                                                         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
7048                                                         VectorMA(ent->modellight_ambient, (1-f)*0.25f, ent->modellight_diffuse, ent->modellight_ambient);
7049                                                         VectorScale(ent->modellight_diffuse, f, ent->modellight_diffuse);
7050                                                 }
7051                                         }
7052                                 }
7053
7054                                 if(r_equalize_entities_to.value > 0 && r_equalize_entities_by.value != 0)
7055                                 {
7056                                         VectorMA(ent->modellight_ambient, 0.25f, ent->modellight_diffuse, avg);
7057                                         f = 0.299f * avg[0] + 0.587f * avg[1] + 0.114f * avg[2];
7058                                         if(f > 0)
7059                                         {
7060                                                 f = pow(f / r_equalize_entities_to.value, -r_equalize_entities_by.value);
7061                                                 VectorScale(ent->modellight_ambient, f, ent->modellight_ambient);
7062                                                 VectorScale(ent->modellight_diffuse, f, ent->modellight_diffuse);
7063                                         }
7064                                 }
7065                         }
7066                 }
7067                 else // highly rare
7068                         VectorSet(ent->modellight_ambient, 1, 1, 1);
7069
7070                 // move the light direction into modelspace coordinates for lighting code
7071                 Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, ent->modellight_lightdir);
7072                 if(VectorLength2(ent->modellight_lightdir) == 0)
7073                         VectorSet(ent->modellight_lightdir, 0, 0, 1); // have to set SOME valid vector here
7074                 VectorNormalize(ent->modellight_lightdir);
7075         }
7076 }
7077
7078 #define MAX_LINEOFSIGHTTRACES 64
7079
7080 static qboolean R_CanSeeBox(int numsamples, vec_t enlarge, vec3_t eye, vec3_t entboxmins, vec3_t entboxmaxs)
7081 {
7082         int i;
7083         vec3_t boxmins, boxmaxs;
7084         vec3_t start;
7085         vec3_t end;
7086         dp_model_t *model = r_refdef.scene.worldmodel;
7087
7088         if (!model || !model->brush.TraceLineOfSight)
7089                 return true;
7090
7091         // expand the box a little
7092         boxmins[0] = (enlarge+1) * entboxmins[0] - enlarge * entboxmaxs[0];
7093         boxmaxs[0] = (enlarge+1) * entboxmaxs[0] - enlarge * entboxmins[0];
7094         boxmins[1] = (enlarge+1) * entboxmins[1] - enlarge * entboxmaxs[1];
7095         boxmaxs[1] = (enlarge+1) * entboxmaxs[1] - enlarge * entboxmins[1];
7096         boxmins[2] = (enlarge+1) * entboxmins[2] - enlarge * entboxmaxs[2];
7097         boxmaxs[2] = (enlarge+1) * entboxmaxs[2] - enlarge * entboxmins[2];
7098
7099         // return true if eye is inside enlarged box
7100         if (BoxesOverlap(boxmins, boxmaxs, eye, eye))
7101                 return true;
7102
7103         // try center
7104         VectorCopy(eye, start);
7105         VectorMAM(0.5f, boxmins, 0.5f, boxmaxs, end);
7106         if (model->brush.TraceLineOfSight(model, start, end))
7107                 return true;
7108
7109         // try various random positions
7110         for (i = 0;i < numsamples;i++)
7111         {
7112                 VectorSet(end, lhrandom(boxmins[0], boxmaxs[0]), lhrandom(boxmins[1], boxmaxs[1]), lhrandom(boxmins[2], boxmaxs[2]));
7113                 if (model->brush.TraceLineOfSight(model, start, end))
7114                         return true;
7115         }
7116
7117         return false;
7118 }
7119
7120
7121 static void R_View_UpdateEntityVisible (void)
7122 {
7123         int i;
7124         int renderimask;
7125         int samples;
7126         entity_render_t *ent;
7127
7128         renderimask = r_refdef.envmap                                    ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL)
7129                 : r_waterstate.renderingrefraction                       ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL)
7130                 : (chase_active.integer || r_waterstate.renderingscene)  ? RENDER_VIEWMODEL
7131                 :                                                          RENDER_EXTERIORMODEL;
7132         if (!r_drawviewmodel.integer)
7133                 renderimask |= RENDER_VIEWMODEL;
7134         if (!r_drawexteriormodel.integer)
7135                 renderimask |= RENDER_EXTERIORMODEL;
7136         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs)
7137         {
7138                 // worldmodel can check visibility
7139                 memset(r_refdef.viewcache.entityvisible, 0, r_refdef.scene.numentities);
7140                 for (i = 0;i < r_refdef.scene.numentities;i++)
7141                 {
7142                         ent = r_refdef.scene.entities[i];
7143                         if (!(ent->flags & renderimask))
7144                         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)))
7145                         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))
7146                                 r_refdef.viewcache.entityvisible[i] = true;
7147                 }
7148                 if(r_cullentities_trace.integer && r_refdef.scene.worldmodel->brush.TraceLineOfSight && !r_refdef.view.useclipplane)
7149                         // sorry, this check doesn't work for portal/reflection/refraction renders as the view origin is not useful for culling
7150                 {
7151                         for (i = 0;i < r_refdef.scene.numentities;i++)
7152                         {
7153                                 ent = r_refdef.scene.entities[i];
7154                                 if(r_refdef.viewcache.entityvisible[i] && !(ent->flags & (RENDER_VIEWMODEL | RENDER_NOCULL | RENDER_NODEPTHTEST)) && !(ent->model && (ent->model->name[0] == '*')))
7155                                 {
7156                                         samples = ent->entitynumber ? r_cullentities_trace_samples.integer : r_cullentities_trace_tempentitysamples.integer;
7157                                         if (samples < 0)
7158                                                 continue; // temp entities do pvs only
7159                                         if(R_CanSeeBox(samples, r_cullentities_trace_enlarge.value, r_refdef.view.origin, ent->mins, ent->maxs))
7160                                                 ent->last_trace_visibility = realtime;
7161                                         if(ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value)
7162                                                 r_refdef.viewcache.entityvisible[i] = 0;
7163                                 }
7164                         }
7165                 }
7166         }
7167         else
7168         {
7169                 // no worldmodel or it can't check visibility
7170                 for (i = 0;i < r_refdef.scene.numentities;i++)
7171                 {
7172                         ent = r_refdef.scene.entities[i];
7173                         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));
7174                 }
7175         }
7176 }
7177
7178 /// only used if skyrendermasked, and normally returns false
7179 int R_DrawBrushModelsSky (void)
7180 {
7181         int i, sky;
7182         entity_render_t *ent;
7183
7184         sky = false;
7185         for (i = 0;i < r_refdef.scene.numentities;i++)
7186         {
7187                 if (!r_refdef.viewcache.entityvisible[i])
7188                         continue;
7189                 ent = r_refdef.scene.entities[i];
7190                 if (!ent->model || !ent->model->DrawSky)
7191                         continue;
7192                 ent->model->DrawSky(ent);
7193                 sky = true;
7194         }
7195         return sky;
7196 }
7197
7198 static void R_DrawNoModel(entity_render_t *ent);
7199 static void R_DrawModels(void)
7200 {
7201         int i;
7202         entity_render_t *ent;
7203
7204         for (i = 0;i < r_refdef.scene.numentities;i++)
7205         {
7206                 if (!r_refdef.viewcache.entityvisible[i])
7207                         continue;
7208                 ent = r_refdef.scene.entities[i];
7209                 r_refdef.stats.entities++;
7210                 if (ent->model && ent->model->Draw != NULL)
7211                         ent->model->Draw(ent);
7212                 else
7213                         R_DrawNoModel(ent);
7214         }
7215 }
7216
7217 static void R_DrawModelsDepth(void)
7218 {
7219         int i;
7220         entity_render_t *ent;
7221
7222         for (i = 0;i < r_refdef.scene.numentities;i++)
7223         {
7224                 if (!r_refdef.viewcache.entityvisible[i])
7225                         continue;
7226                 ent = r_refdef.scene.entities[i];
7227                 if (ent->model && ent->model->DrawDepth != NULL)
7228                         ent->model->DrawDepth(ent);
7229         }
7230 }
7231
7232 static void R_DrawModelsDebug(void)
7233 {
7234         int i;
7235         entity_render_t *ent;
7236
7237         for (i = 0;i < r_refdef.scene.numentities;i++)
7238         {
7239                 if (!r_refdef.viewcache.entityvisible[i])
7240                         continue;
7241                 ent = r_refdef.scene.entities[i];
7242                 if (ent->model && ent->model->DrawDebug != NULL)
7243                         ent->model->DrawDebug(ent);
7244         }
7245 }
7246
7247 static void R_DrawModelsAddWaterPlanes(void)
7248 {
7249         int i;
7250         entity_render_t *ent;
7251
7252         for (i = 0;i < r_refdef.scene.numentities;i++)
7253         {
7254                 if (!r_refdef.viewcache.entityvisible[i])
7255                         continue;
7256                 ent = r_refdef.scene.entities[i];
7257                 if (ent->model && ent->model->DrawAddWaterPlanes != NULL)
7258                         ent->model->DrawAddWaterPlanes(ent);
7259         }
7260 }
7261
7262 static void R_View_SetFrustum(void)
7263 {
7264         int i;
7265         double slopex, slopey;
7266         vec3_t forward, left, up, origin;
7267
7268         // we can't trust r_refdef.view.forward and friends in reflected scenes
7269         Matrix4x4_ToVectors(&r_refdef.view.matrix, forward, left, up, origin);
7270
7271 #if 0
7272         r_refdef.view.frustum[0].normal[0] = 0 - 1.0 / r_refdef.view.frustum_x;
7273         r_refdef.view.frustum[0].normal[1] = 0 - 0;
7274         r_refdef.view.frustum[0].normal[2] = -1 - 0;
7275         r_refdef.view.frustum[1].normal[0] = 0 + 1.0 / r_refdef.view.frustum_x;
7276         r_refdef.view.frustum[1].normal[1] = 0 + 0;
7277         r_refdef.view.frustum[1].normal[2] = -1 + 0;
7278         r_refdef.view.frustum[2].normal[0] = 0 - 0;
7279         r_refdef.view.frustum[2].normal[1] = 0 - 1.0 / r_refdef.view.frustum_y;
7280         r_refdef.view.frustum[2].normal[2] = -1 - 0;
7281         r_refdef.view.frustum[3].normal[0] = 0 + 0;
7282         r_refdef.view.frustum[3].normal[1] = 0 + 1.0 / r_refdef.view.frustum_y;
7283         r_refdef.view.frustum[3].normal[2] = -1 + 0;
7284 #endif
7285
7286 #if 0
7287         zNear = r_refdef.nearclip;
7288         nudge = 1.0 - 1.0 / (1<<23);
7289         r_refdef.view.frustum[4].normal[0] = 0 - 0;
7290         r_refdef.view.frustum[4].normal[1] = 0 - 0;
7291         r_refdef.view.frustum[4].normal[2] = -1 - -nudge;
7292         r_refdef.view.frustum[4].dist = 0 - -2 * zNear * nudge;
7293         r_refdef.view.frustum[5].normal[0] = 0 + 0;
7294         r_refdef.view.frustum[5].normal[1] = 0 + 0;
7295         r_refdef.view.frustum[5].normal[2] = -1 + -nudge;
7296         r_refdef.view.frustum[5].dist = 0 + -2 * zNear * nudge;
7297 #endif
7298
7299
7300
7301 #if 0
7302         r_refdef.view.frustum[0].normal[0] = m[3] - m[0];
7303         r_refdef.view.frustum[0].normal[1] = m[7] - m[4];
7304         r_refdef.view.frustum[0].normal[2] = m[11] - m[8];
7305         r_refdef.view.frustum[0].dist = m[15] - m[12];
7306
7307         r_refdef.view.frustum[1].normal[0] = m[3] + m[0];
7308         r_refdef.view.frustum[1].normal[1] = m[7] + m[4];
7309         r_refdef.view.frustum[1].normal[2] = m[11] + m[8];
7310         r_refdef.view.frustum[1].dist = m[15] + m[12];
7311
7312         r_refdef.view.frustum[2].normal[0] = m[3] - m[1];
7313         r_refdef.view.frustum[2].normal[1] = m[7] - m[5];
7314         r_refdef.view.frustum[2].normal[2] = m[11] - m[9];
7315         r_refdef.view.frustum[2].dist = m[15] - m[13];
7316
7317         r_refdef.view.frustum[3].normal[0] = m[3] + m[1];
7318         r_refdef.view.frustum[3].normal[1] = m[7] + m[5];
7319         r_refdef.view.frustum[3].normal[2] = m[11] + m[9];
7320         r_refdef.view.frustum[3].dist = m[15] + m[13];
7321
7322         r_refdef.view.frustum[4].normal[0] = m[3] - m[2];
7323         r_refdef.view.frustum[4].normal[1] = m[7] - m[6];
7324         r_refdef.view.frustum[4].normal[2] = m[11] - m[10];
7325         r_refdef.view.frustum[4].dist = m[15] - m[14];
7326
7327         r_refdef.view.frustum[5].normal[0] = m[3] + m[2];
7328         r_refdef.view.frustum[5].normal[1] = m[7] + m[6];
7329         r_refdef.view.frustum[5].normal[2] = m[11] + m[10];
7330         r_refdef.view.frustum[5].dist = m[15] + m[14];
7331 #endif
7332
7333         if (r_refdef.view.useperspective)
7334         {
7335                 slopex = 1.0 / r_refdef.view.frustum_x;
7336                 slopey = 1.0 / r_refdef.view.frustum_y;
7337                 VectorMA(forward, -slopex, left, r_refdef.view.frustum[0].normal);
7338                 VectorMA(forward,  slopex, left, r_refdef.view.frustum[1].normal);
7339                 VectorMA(forward, -slopey, up  , r_refdef.view.frustum[2].normal);
7340                 VectorMA(forward,  slopey, up  , r_refdef.view.frustum[3].normal);
7341                 VectorCopy(forward, r_refdef.view.frustum[4].normal);
7342
7343                 // Leaving those out was a mistake, those were in the old code, and they
7344                 // fix a reproducable bug in this one: frustum culling got fucked up when viewmatrix was an identity matrix
7345                 // I couldn't reproduce it after adding those normalizations. --blub
7346                 VectorNormalize(r_refdef.view.frustum[0].normal);
7347                 VectorNormalize(r_refdef.view.frustum[1].normal);
7348                 VectorNormalize(r_refdef.view.frustum[2].normal);
7349                 VectorNormalize(r_refdef.view.frustum[3].normal);
7350
7351                 // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
7352                 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]);
7353                 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]);
7354                 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]);
7355                 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]);
7356
7357                 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal);
7358                 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal);
7359                 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal);
7360                 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal);
7361                 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
7362         }
7363         else
7364         {
7365                 VectorScale(left, -r_refdef.view.ortho_x, r_refdef.view.frustum[0].normal);
7366                 VectorScale(left,  r_refdef.view.ortho_x, r_refdef.view.frustum[1].normal);
7367                 VectorScale(up, -r_refdef.view.ortho_y, r_refdef.view.frustum[2].normal);
7368                 VectorScale(up,  r_refdef.view.ortho_y, r_refdef.view.frustum[3].normal);
7369                 VectorCopy(forward, r_refdef.view.frustum[4].normal);
7370                 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal) + r_refdef.view.ortho_x;
7371                 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal) + r_refdef.view.ortho_x;
7372                 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal) + r_refdef.view.ortho_y;
7373                 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal) + r_refdef.view.ortho_y;
7374                 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
7375         }
7376         r_refdef.view.numfrustumplanes = 5;
7377
7378         if (r_refdef.view.useclipplane)
7379         {
7380                 r_refdef.view.numfrustumplanes = 6;
7381                 r_refdef.view.frustum[5] = r_refdef.view.clipplane;
7382         }
7383
7384         for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
7385                 PlaneClassify(r_refdef.view.frustum + i);
7386
7387         // LordHavoc: note to all quake engine coders, Quake had a special case
7388         // for 90 degrees which assumed a square view (wrong), so I removed it,
7389         // Quake2 has it disabled as well.
7390
7391         // rotate R_VIEWFORWARD right by FOV_X/2 degrees
7392         //RotatePointAroundVector( r_refdef.view.frustum[0].normal, up, forward, -(90 - r_refdef.fov_x / 2));
7393         //r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, frustum[0].normal);
7394         //PlaneClassify(&frustum[0]);
7395
7396         // rotate R_VIEWFORWARD left by FOV_X/2 degrees
7397         //RotatePointAroundVector( r_refdef.view.frustum[1].normal, up, forward, (90 - r_refdef.fov_x / 2));
7398         //r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, frustum[1].normal);
7399         //PlaneClassify(&frustum[1]);
7400
7401         // rotate R_VIEWFORWARD up by FOV_X/2 degrees
7402         //RotatePointAroundVector( r_refdef.view.frustum[2].normal, left, forward, -(90 - r_refdef.fov_y / 2));
7403         //r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, frustum[2].normal);
7404         //PlaneClassify(&frustum[2]);
7405
7406         // rotate R_VIEWFORWARD down by FOV_X/2 degrees
7407         //RotatePointAroundVector( r_refdef.view.frustum[3].normal, left, forward, (90 - r_refdef.fov_y / 2));
7408         //r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, frustum[3].normal);
7409         //PlaneClassify(&frustum[3]);
7410
7411         // nearclip plane
7412         //VectorCopy(forward, r_refdef.view.frustum[4].normal);
7413         //r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, frustum[4].normal) + r_nearclip.value;
7414         //PlaneClassify(&frustum[4]);
7415 }
7416
7417 void R_View_Update(void)
7418 {
7419         R_Main_ResizeViewCache();
7420         R_View_SetFrustum();
7421         R_View_WorldVisibility(r_refdef.view.useclipplane);
7422         R_View_UpdateEntityVisible();
7423         R_View_UpdateEntityLighting();
7424 }
7425
7426 void R_SetupView(qboolean allowwaterclippingplane)
7427 {
7428         const float *customclipplane = NULL;
7429         float plane[4];
7430         if (r_refdef.view.useclipplane && allowwaterclippingplane)
7431         {
7432                 // LordHavoc: couldn't figure out how to make this approach the
7433                 vec_t dist = r_refdef.view.clipplane.dist - r_water_clippingplanebias.value;
7434                 vec_t viewdist = DotProduct(r_refdef.view.origin, r_refdef.view.clipplane.normal);
7435                 if (viewdist < r_refdef.view.clipplane.dist + r_water_clippingplanebias.value)
7436                         dist = r_refdef.view.clipplane.dist;
7437                 plane[0] = r_refdef.view.clipplane.normal[0];
7438                 plane[1] = r_refdef.view.clipplane.normal[1];
7439                 plane[2] = r_refdef.view.clipplane.normal[2];
7440                 plane[3] = dist;
7441                 customclipplane = plane;
7442         }
7443
7444         if (!r_refdef.view.useperspective)
7445                 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);
7446         else if (vid.stencil && r_useinfinitefarclip.integer)
7447                 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);
7448         else
7449                 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);
7450         R_SetViewport(&r_refdef.view.viewport);
7451 }
7452
7453 void R_EntityMatrix(const matrix4x4_t *matrix)
7454 {
7455         if (gl_modelmatrixchanged || memcmp(matrix, &gl_modelmatrix, sizeof(matrix4x4_t)))
7456         {
7457                 gl_modelmatrixchanged = false;
7458                 gl_modelmatrix = *matrix;
7459                 Matrix4x4_Concat(&gl_modelviewmatrix, &gl_viewmatrix, &gl_modelmatrix);
7460                 Matrix4x4_Concat(&gl_modelviewprojectionmatrix, &gl_projectionmatrix, &gl_modelviewmatrix);
7461                 Matrix4x4_ToArrayFloatGL(&gl_modelviewmatrix, gl_modelview16f);
7462                 Matrix4x4_ToArrayFloatGL(&gl_modelviewprojectionmatrix, gl_modelviewprojection16f);
7463                 CHECKGLERROR
7464                 switch(vid.renderpath)
7465                 {
7466                 case RENDERPATH_GL20:
7467                         if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f);
7468                         if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f);
7469                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
7470                         break;
7471                 case RENDERPATH_CGGL:
7472 #ifdef SUPPORTCG
7473                         CHECKCGERROR
7474                         if (r_cg_permutation && r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR
7475                         if (r_cg_permutation && r_cg_permutation->vp_ModelViewMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelview16f);CHECKCGERROR
7476                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
7477 #endif
7478                         break;
7479                 case RENDERPATH_GL13:
7480                 case RENDERPATH_GL11:
7481                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
7482                         break;
7483                 }
7484         }
7485 }
7486
7487 void R_ResetViewRendering2D(void)
7488 {
7489         r_viewport_t viewport;
7490         DrawQ_Finish();
7491
7492         // GL is weird because it's bottom to top, r_refdef.view.y is top to bottom
7493         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);
7494         R_SetViewport(&viewport);
7495         GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
7496         GL_Color(1, 1, 1, 1);
7497         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
7498         GL_BlendFunc(GL_ONE, GL_ZERO);
7499         GL_AlphaTest(false);
7500         GL_ScissorTest(false);
7501         GL_DepthMask(false);
7502         GL_DepthRange(0, 1);
7503         GL_DepthTest(false);
7504         R_EntityMatrix(&identitymatrix);
7505         R_Mesh_ResetTextureState();
7506         GL_PolygonOffset(0, 0);
7507         qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
7508         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
7509         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
7510         qglStencilMask(~0);CHECKGLERROR
7511         qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
7512         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
7513         GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces
7514 }
7515
7516 void R_ResetViewRendering3D(void)
7517 {
7518         DrawQ_Finish();
7519
7520         R_SetupView(true);
7521         GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
7522         GL_Color(1, 1, 1, 1);
7523         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
7524         GL_BlendFunc(GL_ONE, GL_ZERO);
7525         GL_AlphaTest(false);
7526         GL_ScissorTest(true);
7527         GL_DepthMask(true);
7528         GL_DepthRange(0, 1);
7529         GL_DepthTest(true);
7530         R_EntityMatrix(&identitymatrix);
7531         R_Mesh_ResetTextureState();
7532         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
7533         qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
7534         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
7535         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
7536         qglStencilMask(~0);CHECKGLERROR
7537         qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
7538         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
7539         GL_CullFace(r_refdef.view.cullface_back);
7540 }
7541
7542 /*
7543 ================
7544 R_RenderView_UpdateViewVectors
7545 ================
7546 */
7547 static void R_RenderView_UpdateViewVectors(void)
7548 {
7549         // break apart the view matrix into vectors for various purposes
7550         // it is important that this occurs outside the RenderScene function because that can be called from reflection renders, where the vectors come out wrong
7551         // however the r_refdef.view.origin IS updated in RenderScene intentionally - otherwise the sky renders at the wrong origin, etc
7552         Matrix4x4_ToVectors(&r_refdef.view.matrix, r_refdef.view.forward, r_refdef.view.left, r_refdef.view.up, r_refdef.view.origin);
7553         VectorNegate(r_refdef.view.left, r_refdef.view.right);
7554         // make an inverted copy of the view matrix for tracking sprites
7555         Matrix4x4_Invert_Simple(&r_refdef.view.inverse_matrix, &r_refdef.view.matrix);
7556 }
7557
7558 void R_RenderScene(void);
7559 void R_RenderWaterPlanes(void);
7560
7561 static void R_Water_StartFrame(void)
7562 {
7563         int i;
7564         int waterwidth, waterheight, texturewidth, textureheight, camerawidth, cameraheight;
7565         r_waterstate_waterplane_t *p;
7566
7567         if (vid.width > (int)vid.maxtexturesize_2d || vid.height > (int)vid.maxtexturesize_2d)
7568                 return;
7569
7570         switch(vid.renderpath)
7571         {
7572         case RENDERPATH_GL20:
7573         case RENDERPATH_CGGL:
7574                 break;
7575         case RENDERPATH_GL13:
7576         case RENDERPATH_GL11:
7577                 return;
7578         }
7579
7580         // set waterwidth and waterheight to the water resolution that will be
7581         // used (often less than the screen resolution for faster rendering)
7582         waterwidth = (int)bound(1, vid.width * r_water_resolutionmultiplier.value, vid.width);
7583         waterheight = (int)bound(1, vid.height * r_water_resolutionmultiplier.value, vid.height);
7584
7585         // calculate desired texture sizes
7586         // can't use water if the card does not support the texture size
7587         if (!r_water.integer || r_showsurfaces.integer)
7588                 texturewidth = textureheight = waterwidth = waterheight = camerawidth = cameraheight = 0;
7589         else if (vid.support.arb_texture_non_power_of_two)
7590         {
7591                 texturewidth = waterwidth;
7592                 textureheight = waterheight;
7593                 camerawidth = waterwidth;
7594                 cameraheight = waterheight;
7595         }
7596         else
7597         {
7598                 for (texturewidth   = 1;texturewidth   < waterwidth ;texturewidth   *= 2);
7599                 for (textureheight  = 1;textureheight  < waterheight;textureheight  *= 2);
7600                 for (camerawidth    = 1;camerawidth   <= waterwidth; camerawidth    *= 2); camerawidth  /= 2;
7601                 for (cameraheight   = 1;cameraheight  <= waterheight;cameraheight   *= 2); cameraheight /= 2;
7602         }
7603
7604         // allocate textures as needed
7605         if (r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight || r_waterstate.camerawidth != camerawidth || r_waterstate.cameraheight != cameraheight)
7606         {
7607                 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
7608                 for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
7609                 {
7610                         if (p->texture_refraction)
7611                                 R_FreeTexture(p->texture_refraction);
7612                         p->texture_refraction = NULL;
7613                         if (p->texture_reflection)
7614                                 R_FreeTexture(p->texture_reflection);
7615                         p->texture_reflection = NULL;
7616                         if (p->texture_camera)
7617                                 R_FreeTexture(p->texture_camera);
7618                         p->texture_camera = NULL;
7619                 }
7620                 memset(&r_waterstate, 0, sizeof(r_waterstate));
7621                 r_waterstate.texturewidth = texturewidth;
7622                 r_waterstate.textureheight = textureheight;
7623                 r_waterstate.camerawidth = camerawidth;
7624                 r_waterstate.cameraheight = cameraheight;
7625         }
7626
7627         if (r_waterstate.texturewidth)
7628         {
7629                 r_waterstate.enabled = true;
7630
7631                 // when doing a reduced render (HDR) we want to use a smaller area
7632                 r_waterstate.waterwidth = (int)bound(1, r_refdef.view.width * r_water_resolutionmultiplier.value, r_refdef.view.width);
7633                 r_waterstate.waterheight = (int)bound(1, r_refdef.view.height * r_water_resolutionmultiplier.value, r_refdef.view.height);
7634
7635                 // set up variables that will be used in shader setup
7636                 r_waterstate.screenscale[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
7637                 r_waterstate.screenscale[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
7638                 r_waterstate.screencenter[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
7639                 r_waterstate.screencenter[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
7640         }
7641
7642         r_waterstate.maxwaterplanes = MAX_WATERPLANES;
7643         r_waterstate.numwaterplanes = 0;
7644 }
7645
7646 void R_Water_AddWaterPlane(msurface_t *surface)
7647 {
7648         int triangleindex, planeindex;
7649         const int *e;
7650         vec3_t vert[3];
7651         vec3_t normal;
7652         vec3_t center;
7653         mplane_t plane;
7654         int cam_ent;
7655         r_waterstate_waterplane_t *p;
7656         texture_t *t = R_GetCurrentTexture(surface->texture);
7657         cam_ent = t->camera_entity;
7658         if(!(t->currentmaterialflags & MATERIALFLAG_CAMERA))
7659                 cam_ent = 0;
7660
7661         // just use the first triangle with a valid normal for any decisions
7662         VectorClear(normal);
7663         for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
7664         {
7665                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
7666                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
7667                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
7668                 TriangleNormal(vert[0], vert[1], vert[2], normal);
7669                 if (VectorLength2(normal) >= 0.001)
7670                         break;
7671         }
7672
7673         VectorCopy(normal, plane.normal);
7674         VectorNormalize(plane.normal);
7675         plane.dist = DotProduct(vert[0], plane.normal);
7676         PlaneClassify(&plane);
7677         if (PlaneDiff(r_refdef.view.origin, &plane) < 0)
7678         {
7679                 // skip backfaces (except if nocullface is set)
7680                 if (!(t->currentmaterialflags & MATERIALFLAG_NOCULLFACE))
7681                         return;
7682                 VectorNegate(plane.normal, plane.normal);
7683                 plane.dist *= -1;
7684                 PlaneClassify(&plane);
7685         }
7686
7687
7688         // find a matching plane if there is one
7689         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
7690                 if(p->camera_entity == t->camera_entity)
7691                         if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
7692                                 break;
7693         if (planeindex >= r_waterstate.maxwaterplanes)
7694                 return; // nothing we can do, out of planes
7695
7696         // if this triangle does not fit any known plane rendered this frame, add one
7697         if (planeindex >= r_waterstate.numwaterplanes)
7698         {
7699                 // store the new plane
7700                 r_waterstate.numwaterplanes++;
7701                 p->plane = plane;
7702                 // clear materialflags and pvs
7703                 p->materialflags = 0;
7704                 p->pvsvalid = false;
7705                 p->camera_entity = t->camera_entity;
7706         }
7707         // merge this surface's materialflags into the waterplane
7708         p->materialflags |= t->currentmaterialflags;
7709         if(!(p->materialflags & MATERIALFLAG_CAMERA))
7710         {
7711                 // merge this surface's PVS into the waterplane
7712                 VectorMAM(0.5f, surface->mins, 0.5f, surface->maxs, center);
7713                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS
7714                  && r_refdef.scene.worldmodel->brush.PointInLeaf && r_refdef.scene.worldmodel->brush.PointInLeaf(r_refdef.scene.worldmodel, center)->clusterindex >= 0)
7715                 {
7716                         r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, center, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
7717                         p->pvsvalid = true;
7718                 }
7719         }
7720 }
7721
7722 static void R_Water_ProcessPlanes(void)
7723 {
7724         r_refdef_view_t originalview;
7725         r_refdef_view_t myview;
7726         int planeindex;
7727         r_waterstate_waterplane_t *p;
7728         vec3_t visorigin;
7729
7730         originalview = r_refdef.view;
7731
7732         // make sure enough textures are allocated
7733         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
7734         {
7735                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
7736                 {
7737                         if (!p->texture_refraction)
7738                                 p->texture_refraction = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_refraction", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
7739                         if (!p->texture_refraction)
7740                                 goto error;
7741                 }
7742                 else if (p->materialflags & MATERIALFLAG_CAMERA)
7743                 {
7744                         if (!p->texture_camera)
7745                                 p->texture_camera = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_camera", planeindex), r_waterstate.camerawidth, r_waterstate.cameraheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCELINEAR, -1, NULL);
7746                         if (!p->texture_camera)
7747                                 goto error;
7748                 }
7749
7750                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
7751                 {
7752                         if (!p->texture_reflection)
7753                                 p->texture_reflection = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_reflection", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
7754                         if (!p->texture_reflection)
7755                                 goto error;
7756                 }
7757         }
7758
7759         // render views
7760         r_refdef.view = originalview;
7761         r_refdef.view.showdebug = false;
7762         r_refdef.view.width = r_waterstate.waterwidth;
7763         r_refdef.view.height = r_waterstate.waterheight;
7764         r_refdef.view.useclipplane = true;
7765         myview = r_refdef.view;
7766         r_waterstate.renderingscene = true;
7767         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
7768         {
7769                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
7770                 {
7771                         r_refdef.view = myview;
7772                         // render reflected scene and copy into texture
7773                         Matrix4x4_Reflect(&r_refdef.view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
7774                         // update the r_refdef.view.origin because otherwise the sky renders at the wrong location (amongst other problems)
7775                         Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, r_refdef.view.origin);
7776                         r_refdef.view.clipplane = p->plane;
7777                         // reverse the cullface settings for this render
7778                         r_refdef.view.cullface_front = GL_FRONT;
7779                         r_refdef.view.cullface_back = GL_BACK;
7780                         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.num_pvsclusterbytes)
7781                         {
7782                                 r_refdef.view.usecustompvs = true;
7783                                 if (p->pvsvalid)
7784                                         memcpy(r_refdef.viewcache.world_pvsbits, p->pvsbits, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
7785                                 else
7786                                         memset(r_refdef.viewcache.world_pvsbits, 0xFF, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
7787                         }
7788
7789                         R_ResetViewRendering3D();
7790                         R_ClearScreen(r_refdef.fogenabled);
7791                         R_View_Update();
7792                         R_RenderScene();
7793
7794                         R_Mesh_CopyToTexture(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);
7795                 }
7796
7797                 // render the normal view scene and copy into texture
7798                 // (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)
7799                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
7800                 {
7801                         r_waterstate.renderingrefraction = true;
7802                         r_refdef.view = myview;
7803
7804                         r_refdef.view.clipplane = p->plane;
7805                         VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
7806                         r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
7807
7808                         if((p->materialflags & MATERIALFLAG_CAMERA) && p->camera_entity)
7809                         {
7810                                 // we need to perform a matrix transform to render the view... so let's get the transformation matrix
7811                                 r_waterstate.renderingrefraction = false; // we don't want to hide the player model from these ones
7812                                 CL_VM_TransformView(p->camera_entity - MAX_EDICTS, &r_refdef.view.matrix, &r_refdef.view.clipplane, visorigin);
7813                                 R_RenderView_UpdateViewVectors();
7814                                 r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, visorigin, 2, r_refdef.viewcache.world_pvsbits, (r_refdef.viewcache.world_numclusters+7)>>3, false);
7815                         }
7816
7817                         PlaneClassify(&r_refdef.view.clipplane);
7818
7819                         R_ResetViewRendering3D();
7820                         R_ClearScreen(r_refdef.fogenabled);
7821                         R_View_Update();
7822                         R_RenderScene();
7823
7824                         R_Mesh_CopyToTexture(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);
7825                         r_waterstate.renderingrefraction = false;
7826                 }
7827                 else if (p->materialflags & MATERIALFLAG_CAMERA)
7828                 {
7829                         r_refdef.view = myview;
7830
7831                         r_refdef.view.clipplane = p->plane;
7832                         VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
7833                         r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
7834
7835                         r_refdef.view.width = r_waterstate.camerawidth;
7836                         r_refdef.view.height = r_waterstate.cameraheight;
7837                         r_refdef.view.frustum_x = 1; // tan(45 * M_PI / 180.0);
7838                         r_refdef.view.frustum_y = 1; // tan(45 * M_PI / 180.0);
7839
7840                         if(p->camera_entity)
7841                         {
7842                                 // we need to perform a matrix transform to render the view... so let's get the transformation matrix
7843                                 CL_VM_TransformView(p->camera_entity - MAX_EDICTS, &r_refdef.view.matrix, &r_refdef.view.clipplane, visorigin);
7844                         }
7845
7846                         // reverse the cullface settings for this render
7847                         r_refdef.view.cullface_front = GL_FRONT;
7848                         r_refdef.view.cullface_back = GL_BACK;
7849                         // also reverse the view matrix
7850                         Matrix4x4_ConcatScale3(&r_refdef.view.matrix, 1, 1, -1); // this serves to invert texcoords in the result, as the copied texture is mapped the wrong way round
7851                         R_RenderView_UpdateViewVectors();
7852                         if(p->camera_entity)
7853                                 r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, visorigin, 2, r_refdef.viewcache.world_pvsbits, (r_refdef.viewcache.world_numclusters+7)>>3, false);
7854
7855                         // camera needs no clipplane
7856                         r_refdef.view.useclipplane = false;
7857
7858                         PlaneClassify(&r_refdef.view.clipplane);
7859
7860                         R_ResetViewRendering3D();
7861                         R_ClearScreen(r_refdef.fogenabled);
7862                         R_View_Update();
7863                         R_RenderScene();
7864
7865                         R_Mesh_CopyToTexture(p->texture_camera, 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
7866                         r_waterstate.renderingrefraction = false;
7867                 }
7868
7869         }
7870         r_waterstate.renderingscene = false;
7871         r_refdef.view = originalview;
7872         R_ResetViewRendering3D();
7873         R_ClearScreen(r_refdef.fogenabled);
7874         R_View_Update();
7875         return;
7876 error:
7877         r_refdef.view = originalview;
7878         r_waterstate.renderingscene = false;
7879         Cvar_SetValueQuick(&r_water, 0);
7880         Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed!  Turned off r_water.\n");
7881         return;
7882 }
7883
7884 void R_Bloom_StartFrame(void)
7885 {
7886         int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
7887
7888         switch(vid.renderpath)
7889         {
7890         case RENDERPATH_GL20:
7891         case RENDERPATH_CGGL:
7892                 break;
7893         case RENDERPATH_GL13:
7894         case RENDERPATH_GL11:
7895                 return;
7896         }
7897
7898         // set bloomwidth and bloomheight to the bloom resolution that will be
7899         // used (often less than the screen resolution for faster rendering)
7900         r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, vid.height);
7901         r_bloomstate.bloomheight = r_bloomstate.bloomwidth * vid.height / vid.width;
7902         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, vid.height);
7903         r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, (int)vid.maxtexturesize_2d);
7904         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, (int)vid.maxtexturesize_2d);
7905
7906         // calculate desired texture sizes
7907         if (vid.support.arb_texture_non_power_of_two)
7908         {
7909                 screentexturewidth = r_refdef.view.width;
7910                 screentextureheight = r_refdef.view.height;
7911                 bloomtexturewidth = r_bloomstate.bloomwidth;
7912                 bloomtextureheight = r_bloomstate.bloomheight;
7913         }
7914         else
7915         {
7916                 for (screentexturewidth  = 1;screentexturewidth  < vid.width               ;screentexturewidth  *= 2);
7917                 for (screentextureheight = 1;screentextureheight < vid.height              ;screentextureheight *= 2);
7918                 for (bloomtexturewidth   = 1;bloomtexturewidth   < r_bloomstate.bloomwidth ;bloomtexturewidth   *= 2);
7919                 for (bloomtextureheight  = 1;bloomtextureheight  < r_bloomstate.bloomheight;bloomtextureheight  *= 2);
7920         }
7921
7922         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))
7923         {
7924                 Cvar_SetValueQuick(&r_hdr, 0);
7925                 Cvar_SetValueQuick(&r_bloom, 0);
7926                 Cvar_SetValueQuick(&r_motionblur, 0);
7927                 Cvar_SetValueQuick(&r_damageblur, 0);
7928         }
7929
7930         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)))
7931                 screentexturewidth = screentextureheight = 0;
7932         if (!r_hdr.integer && !r_bloom.integer)
7933                 bloomtexturewidth = bloomtextureheight = 0;
7934
7935         // allocate textures as needed
7936         if (r_bloomstate.screentexturewidth != screentexturewidth || r_bloomstate.screentextureheight != screentextureheight)
7937         {
7938                 if (r_bloomstate.texture_screen)
7939                         R_FreeTexture(r_bloomstate.texture_screen);
7940                 r_bloomstate.texture_screen = NULL;
7941                 r_bloomstate.screentexturewidth = screentexturewidth;
7942                 r_bloomstate.screentextureheight = screentextureheight;
7943                 if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight)
7944                         r_bloomstate.texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", r_bloomstate.screentexturewidth, r_bloomstate.screentextureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCENEAREST | TEXF_CLAMP, -1, NULL);
7945         }
7946         if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight)
7947         {
7948                 if (r_bloomstate.texture_bloom)
7949                         R_FreeTexture(r_bloomstate.texture_bloom);
7950                 r_bloomstate.texture_bloom = NULL;
7951                 r_bloomstate.bloomtexturewidth = bloomtexturewidth;
7952                 r_bloomstate.bloomtextureheight = bloomtextureheight;
7953                 if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight)
7954                         r_bloomstate.texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", r_bloomstate.bloomtexturewidth, r_bloomstate.bloomtextureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
7955         }
7956
7957         // when doing a reduced render (HDR) we want to use a smaller area
7958         r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, r_refdef.view.height);
7959         r_bloomstate.bloomheight = r_bloomstate.bloomwidth * r_refdef.view.height / r_refdef.view.width;
7960         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_refdef.view.height);
7961         r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, r_bloomstate.bloomtexturewidth);
7962         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_bloomstate.bloomtextureheight);
7963
7964         // set up a texcoord array for the full resolution screen image
7965         // (we have to keep this around to copy back during final render)
7966         r_bloomstate.screentexcoord2f[0] = 0;
7967         r_bloomstate.screentexcoord2f[1] = (float)r_refdef.view.height    / (float)r_bloomstate.screentextureheight;
7968         r_bloomstate.screentexcoord2f[2] = (float)r_refdef.view.width     / (float)r_bloomstate.screentexturewidth;
7969         r_bloomstate.screentexcoord2f[3] = (float)r_refdef.view.height    / (float)r_bloomstate.screentextureheight;
7970         r_bloomstate.screentexcoord2f[4] = (float)r_refdef.view.width     / (float)r_bloomstate.screentexturewidth;
7971         r_bloomstate.screentexcoord2f[5] = 0;
7972         r_bloomstate.screentexcoord2f[6] = 0;
7973         r_bloomstate.screentexcoord2f[7] = 0;
7974
7975         // set up a texcoord array for the reduced resolution bloom image
7976         // (which will be additive blended over the screen image)
7977         r_bloomstate.bloomtexcoord2f[0] = 0;
7978         r_bloomstate.bloomtexcoord2f[1] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
7979         r_bloomstate.bloomtexcoord2f[2] = (float)r_bloomstate.bloomwidth  / (float)r_bloomstate.bloomtexturewidth;
7980         r_bloomstate.bloomtexcoord2f[3] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
7981         r_bloomstate.bloomtexcoord2f[4] = (float)r_bloomstate.bloomwidth  / (float)r_bloomstate.bloomtexturewidth;
7982         r_bloomstate.bloomtexcoord2f[5] = 0;
7983         r_bloomstate.bloomtexcoord2f[6] = 0;
7984         r_bloomstate.bloomtexcoord2f[7] = 0;
7985
7986         if (r_hdr.integer || r_bloom.integer)
7987         {
7988                 r_bloomstate.enabled = true;
7989                 r_bloomstate.hdr = r_hdr.integer != 0;
7990         }
7991
7992         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);
7993 }
7994
7995 void R_Bloom_CopyBloomTexture(float colorscale)
7996 {
7997         r_refdef.stats.bloom++;
7998
7999         // scale down screen texture to the bloom texture size
8000         CHECKGLERROR
8001         R_SetViewport(&r_bloomstate.viewport);
8002         GL_BlendFunc(GL_ONE, GL_ZERO);
8003         GL_Color(colorscale, colorscale, colorscale, 1);
8004         // TODO: optimize with multitexture or GLSL
8005         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
8006         R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
8007         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8008         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
8009
8010         // we now have a bloom image in the framebuffer
8011         // copy it into the bloom image texture for later processing
8012         R_Mesh_CopyToTexture(r_bloomstate.texture_bloom, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);
8013         r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
8014 }
8015
8016 void R_Bloom_CopyHDRTexture(void)
8017 {
8018         R_Mesh_CopyToTexture(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);
8019         r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
8020 }
8021
8022 void R_Bloom_MakeTexture(void)
8023 {
8024         int x, range, dir;
8025         float xoffset, yoffset, r, brighten;
8026
8027         r_refdef.stats.bloom++;
8028
8029         R_ResetViewRendering2D();
8030         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
8031         R_Mesh_ColorPointer(NULL, 0, 0);
8032
8033         // we have a bloom image in the framebuffer
8034         CHECKGLERROR
8035         R_SetViewport(&r_bloomstate.viewport);
8036
8037         for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
8038         {
8039                 x *= 2;
8040                 r = bound(0, r_bloom_colorexponent.value / x, 1);
8041                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
8042                 GL_Color(r, r, r, 1);
8043                 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
8044                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
8045                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8046                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
8047
8048                 // copy the vertically blurred bloom view to a texture
8049                 R_Mesh_CopyToTexture(r_bloomstate.texture_bloom, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);
8050                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
8051         }
8052
8053         range = r_bloom_blur.integer * r_bloomstate.bloomwidth / 320;
8054         brighten = r_bloom_brighten.value;
8055         if (r_hdr.integer)
8056                 brighten *= r_hdr_range.value;
8057         brighten = sqrt(brighten);
8058         if(range >= 1)
8059                 brighten *= (3 * range) / (2 * range - 1); // compensate for the "dot particle"
8060         R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
8061         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.offsettexcoord2f, 0, 0);
8062
8063         for (dir = 0;dir < 2;dir++)
8064         {
8065                 // blend on at multiple vertical offsets to achieve a vertical blur
8066                 // TODO: do offset blends using GLSL
8067                 // TODO instead of changing the texcoords, change the target positions to prevent artifacts at edges
8068                 GL_BlendFunc(GL_ONE, GL_ZERO);
8069                 for (x = -range;x <= range;x++)
8070                 {
8071                         if (!dir){xoffset = 0;yoffset = x;}
8072                         else {xoffset = x;yoffset = 0;}
8073                         xoffset /= (float)r_bloomstate.bloomtexturewidth;
8074                         yoffset /= (float)r_bloomstate.bloomtextureheight;
8075                         // compute a texcoord array with the specified x and y offset
8076                         r_bloomstate.offsettexcoord2f[0] = xoffset+0;
8077                         r_bloomstate.offsettexcoord2f[1] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
8078                         r_bloomstate.offsettexcoord2f[2] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
8079                         r_bloomstate.offsettexcoord2f[3] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
8080                         r_bloomstate.offsettexcoord2f[4] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
8081                         r_bloomstate.offsettexcoord2f[5] = yoffset+0;
8082                         r_bloomstate.offsettexcoord2f[6] = xoffset+0;
8083                         r_bloomstate.offsettexcoord2f[7] = yoffset+0;
8084                         // this r value looks like a 'dot' particle, fading sharply to
8085                         // black at the edges
8086                         // (probably not realistic but looks good enough)
8087                         //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
8088                         //r = brighten/(range*2+1);
8089                         r = brighten / (range * 2 + 1);
8090                         if(range >= 1)
8091                                 r *= (1 - x*x/(float)(range*range));
8092                         GL_Color(r, r, r, 1);
8093                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8094                         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
8095                         GL_BlendFunc(GL_ONE, GL_ONE);
8096                 }
8097
8098                 // copy the vertically blurred bloom view to a texture
8099                 R_Mesh_CopyToTexture(r_bloomstate.texture_bloom, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);
8100                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
8101         }
8102
8103         // apply subtract last
8104         // (just like it would be in a GLSL shader)
8105         if (r_bloom_colorsubtract.value > 0 && vid.support.ext_blend_subtract)
8106         {
8107                 GL_BlendFunc(GL_ONE, GL_ZERO);
8108                 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
8109                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
8110                 GL_Color(1, 1, 1, 1);
8111                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8112                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
8113
8114                 GL_BlendFunc(GL_ONE, GL_ONE);
8115                 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
8116                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8117                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
8118                 GL_Color(r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 1);
8119                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8120                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
8121                 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
8122
8123                 // copy the darkened bloom view to a texture
8124                 R_Mesh_CopyToTexture(r_bloomstate.texture_bloom, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);
8125                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
8126         }
8127 }
8128
8129 void R_HDR_RenderBloomTexture(void)
8130 {
8131         int oldwidth, oldheight;
8132         float oldcolorscale;
8133
8134         oldcolorscale = r_refdef.view.colorscale;
8135         oldwidth = r_refdef.view.width;
8136         oldheight = r_refdef.view.height;
8137         r_refdef.view.width = r_bloomstate.bloomwidth;
8138         r_refdef.view.height = r_bloomstate.bloomheight;
8139
8140         // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer?  it might improve SLI performance.
8141         // TODO: add exposure compensation features
8142         // TODO: add fp16 framebuffer support (using GL_EXT_framebuffer_object)
8143
8144         r_refdef.view.showdebug = false;
8145         r_refdef.view.colorscale *= r_bloom_colorscale.value / bound(1, r_hdr_range.value, 16);
8146
8147         R_ResetViewRendering3D();
8148
8149         R_ClearScreen(r_refdef.fogenabled);
8150         if (r_timereport_active)
8151                 R_TimeReport("HDRclear");
8152
8153         R_View_Update();
8154         if (r_timereport_active)
8155                 R_TimeReport("visibility");
8156
8157         // only do secondary renders with HDR if r_hdr is 2 or higher
8158         r_waterstate.numwaterplanes = 0;
8159         if (r_waterstate.enabled && r_hdr.integer >= 2)
8160                 R_RenderWaterPlanes();
8161
8162         r_refdef.view.showdebug = true;
8163         R_RenderScene();
8164         r_waterstate.numwaterplanes = 0;
8165
8166         R_ResetViewRendering2D();
8167
8168         R_Bloom_CopyHDRTexture();
8169         R_Bloom_MakeTexture();
8170
8171         // restore the view settings
8172         r_refdef.view.width = oldwidth;
8173         r_refdef.view.height = oldheight;
8174         r_refdef.view.colorscale = oldcolorscale;
8175
8176         R_ResetViewRendering3D();
8177
8178         R_ClearScreen(r_refdef.fogenabled);
8179         if (r_timereport_active)
8180                 R_TimeReport("viewclear");
8181 }
8182
8183 static void R_BlendView(void)
8184 {
8185         unsigned int permutation;
8186         float uservecs[4][4];
8187
8188         switch (vid.renderpath)
8189         {
8190         case RENDERPATH_GL20:
8191         case RENDERPATH_CGGL:
8192                 permutation =
8193                           (r_bloomstate.texture_bloom ? SHADERPERMUTATION_BLOOM : 0)
8194                         | (r_refdef.viewblend[3] > 0 ? SHADERPERMUTATION_VIEWTINT : 0)
8195                         | ((v_glslgamma.value && !vid_gammatables_trivial) ? SHADERPERMUTATION_GAMMARAMPS : 0)
8196                         | (r_glsl_postprocess.integer ? SHADERPERMUTATION_POSTPROCESSING : 0)
8197                         | ((!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) ? SHADERPERMUTATION_SATURATION : 0);
8198
8199                 if (r_bloomstate.texture_screen)
8200                 {
8201                         // make sure the buffer is available
8202                         if (r_bloom_blur.value < 1) { Cvar_SetValueQuick(&r_bloom_blur, 1); }
8203
8204                         R_ResetViewRendering2D();
8205                         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
8206                         R_Mesh_ColorPointer(NULL, 0, 0);
8207
8208                         if(!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0))
8209                         {
8210                                 // declare variables
8211                                 float speed;
8212                                 static float avgspeed;
8213
8214                                 speed = VectorLength(cl.movement_velocity);
8215
8216                                 cl.motionbluralpha = bound(0, (cl.time - cl.oldtime) / max(0.001, r_motionblur_vcoeff.value), 1);
8217                                 avgspeed = avgspeed * (1 - cl.motionbluralpha) + speed * cl.motionbluralpha;
8218
8219                                 speed = (avgspeed - r_motionblur_vmin.value) / max(1, r_motionblur_vmax.value - r_motionblur_vmin.value);
8220                                 speed = bound(0, speed, 1);
8221                                 speed = speed * (1 - r_motionblur_bmin.value) + r_motionblur_bmin.value;
8222
8223                                 // calculate values into a standard alpha
8224                                 cl.motionbluralpha = 1 - exp(-
8225                                                 (
8226                                                  (r_motionblur.value * speed / 80)
8227                                                  +
8228                                                  (r_damageblur.value * (cl.cshifts[CSHIFT_DAMAGE].percent / 1600))
8229                                                 )
8230                                                 /
8231                                                 max(0.0001, cl.time - cl.oldtime) // fps independent
8232                                            );
8233
8234                                 cl.motionbluralpha *= lhrandom(1 - r_motionblur_randomize.value, 1 + r_motionblur_randomize.value);
8235                                 cl.motionbluralpha = bound(0, cl.motionbluralpha, r_motionblur_maxblur.value);
8236                                 // apply the blur
8237                                 if (cl.motionbluralpha > 0 && !r_refdef.envmap)
8238                                 {
8239                                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
8240                                         GL_Color(1, 1, 1, cl.motionbluralpha);
8241                                         R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
8242                                         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
8243                                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8244                                         r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
8245                                 }
8246                         }
8247
8248                         // copy view into the screen texture
8249                         R_Mesh_CopyToTexture(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);
8250                         r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
8251                 }
8252                 else if (!r_bloomstate.texture_bloom)
8253                 {
8254                         // we may still have to do view tint...
8255                         if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
8256                         {
8257                                 // apply a color tint to the whole view
8258                                 R_ResetViewRendering2D();
8259                                 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
8260                                 R_Mesh_ColorPointer(NULL, 0, 0);
8261                                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8262                                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
8263                                 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
8264                                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8265                         }
8266                         break; // no screen processing, no bloom, skip it
8267                 }
8268
8269                 if (r_bloomstate.texture_bloom && !r_bloomstate.hdr)
8270                 {
8271                         // render simple bloom effect
8272                         // copy the screen and shrink it and darken it for the bloom process
8273                         R_Bloom_CopyBloomTexture(r_bloom_colorscale.value);
8274                         // make the bloom texture
8275                         R_Bloom_MakeTexture();
8276                 }
8277
8278 #if _MSC_VER >= 1400
8279 #define sscanf sscanf_s
8280 #endif
8281                 memset(uservecs, 0, sizeof(uservecs));
8282                 sscanf(r_glsl_postprocess_uservec1.string, "%f %f %f %f", &uservecs[0][0], &uservecs[0][1], &uservecs[0][2], &uservecs[0][3]);
8283                 sscanf(r_glsl_postprocess_uservec2.string, "%f %f %f %f", &uservecs[1][0], &uservecs[1][1], &uservecs[1][2], &uservecs[1][3]);
8284                 sscanf(r_glsl_postprocess_uservec3.string, "%f %f %f %f", &uservecs[2][0], &uservecs[2][1], &uservecs[2][2], &uservecs[2][3]);
8285                 sscanf(r_glsl_postprocess_uservec4.string, "%f %f %f %f", &uservecs[3][0], &uservecs[3][1], &uservecs[3][2], &uservecs[3][3]);
8286
8287                 R_ResetViewRendering2D();
8288                 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
8289                 R_Mesh_ColorPointer(NULL, 0, 0);
8290                 GL_Color(1, 1, 1, 1);
8291                 GL_BlendFunc(GL_ONE, GL_ZERO);
8292                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
8293                 R_Mesh_TexCoordPointer(1, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
8294
8295                 switch(vid.renderpath)
8296                 {
8297                 case RENDERPATH_GL20:
8298                         R_SetupShader_SetPermutationGLSL(SHADERMODE_POSTPROCESS, permutation);
8299                         if (r_glsl_permutation->loc_Texture_First      >= 0) R_Mesh_TexBind(GL20TU_FIRST     , r_bloomstate.texture_screen);
8300                         if (r_glsl_permutation->loc_Texture_Second     >= 0) R_Mesh_TexBind(GL20TU_SECOND    , r_bloomstate.texture_bloom );
8301                         if (r_glsl_permutation->loc_Texture_GammaRamps >= 0) R_Mesh_TexBind(GL20TU_GAMMARAMPS, r_texture_gammaramps       );
8302                         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]);
8303                         if (r_glsl_permutation->loc_PixelSize          >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelSize         , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);
8304                         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]);
8305                         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]);
8306                         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]);
8307                         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]);
8308                         if (r_glsl_permutation->loc_Saturation         >= 0) qglUniform1fARB(r_glsl_permutation->loc_Saturation        , r_glsl_saturation.value);
8309                         if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
8310                         break;
8311                 case RENDERPATH_CGGL:
8312 #ifdef SUPPORTCG
8313                         R_SetupShader_SetPermutationCG(SHADERMODE_POSTPROCESS, permutation);
8314                         if (r_cg_permutation->fp_Texture_First     ) CG_BindTexture(r_cg_permutation->fp_Texture_First     , r_bloomstate.texture_screen);CHECKCGERROR
8315                         if (r_cg_permutation->fp_Texture_Second    ) CG_BindTexture(r_cg_permutation->fp_Texture_Second    , r_bloomstate.texture_bloom );CHECKCGERROR
8316                         if (r_cg_permutation->fp_Texture_GammaRamps) CG_BindTexture(r_cg_permutation->fp_Texture_GammaRamps, r_texture_gammaramps       );CHECKCGERROR
8317                         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
8318                         if (r_cg_permutation->fp_PixelSize         ) cgGLSetParameter2f(     r_cg_permutation->fp_PixelSize         , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);CHECKCGERROR
8319                         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
8320                         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
8321                         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
8322                         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
8323                         if (r_cg_permutation->fp_Saturation        ) cgGLSetParameter1f(     r_cg_permutation->fp_Saturation        , r_glsl_saturation.value);CHECKCGERROR
8324                         if (r_cg_permutation->fp_PixelToScreenTexCoord) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR
8325 #endif
8326                         break;
8327                 default:
8328                         break;
8329                 }
8330                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8331                 r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
8332                 break;
8333         case RENDERPATH_GL13:
8334         case RENDERPATH_GL11:
8335                 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
8336                 {
8337                         // apply a color tint to the whole view
8338                         R_ResetViewRendering2D();
8339                         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
8340                         R_Mesh_ColorPointer(NULL, 0, 0);
8341                         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8342                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
8343                         GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
8344                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8345                 }
8346                 break;
8347         }
8348 }
8349
8350 matrix4x4_t r_waterscrollmatrix;
8351
8352 void R_UpdateFogColor(void) // needs to be called before HDR subrender too, as that changes colorscale!
8353 {
8354         if (r_refdef.fog_density)
8355         {
8356                 r_refdef.fogcolor[0] = r_refdef.fog_red;
8357                 r_refdef.fogcolor[1] = r_refdef.fog_green;
8358                 r_refdef.fogcolor[2] = r_refdef.fog_blue;
8359
8360                 Vector4Set(r_refdef.fogplane, 0, 0, 1, -r_refdef.fog_height);
8361                 r_refdef.fogplaneviewdist = DotProduct(r_refdef.fogplane, r_refdef.view.origin) + r_refdef.fogplane[3];
8362                 r_refdef.fogplaneviewabove = r_refdef.fogplaneviewdist >= 0;
8363                 r_refdef.fogheightfade = -0.5f/max(0.125f, r_refdef.fog_fadedepth);
8364
8365                 {
8366                         vec3_t fogvec;
8367                         VectorCopy(r_refdef.fogcolor, fogvec);
8368                         //   color.rgb *= ContrastBoost * SceneBrightness;
8369                         VectorScale(fogvec, r_refdef.view.colorscale, fogvec);
8370                         r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
8371                         r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
8372                         r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
8373                 }
8374         }
8375 }
8376
8377 void R_UpdateVariables(void)
8378 {
8379         R_Textures_Frame();
8380
8381         r_refdef.scene.ambient = r_ambient.value * (1.0f / 64.0f);
8382
8383         r_refdef.farclip = r_farclip_base.value;
8384         if (r_refdef.scene.worldmodel)
8385                 r_refdef.farclip += r_refdef.scene.worldmodel->radius * r_farclip_world.value * 2;
8386         r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
8387
8388         if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
8389                 Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
8390         r_refdef.polygonfactor = 0;
8391         r_refdef.polygonoffset = 0;
8392         r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
8393         r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
8394
8395         r_refdef.scene.rtworld = r_shadow_realtime_world.integer != 0;
8396         r_refdef.scene.rtworldshadows = r_shadow_realtime_world_shadows.integer && vid.stencil;
8397         r_refdef.scene.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer;
8398         r_refdef.scene.rtdlightshadows = r_refdef.scene.rtdlight && r_shadow_realtime_dlight_shadows.integer && vid.stencil;
8399         r_refdef.lightmapintensity = r_refdef.scene.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
8400         if (r_showsurfaces.integer)
8401         {
8402                 r_refdef.scene.rtworld = false;
8403                 r_refdef.scene.rtworldshadows = false;
8404                 r_refdef.scene.rtdlight = false;
8405                 r_refdef.scene.rtdlightshadows = false;
8406                 r_refdef.lightmapintensity = 0;
8407         }
8408
8409         if (gamemode == GAME_NEHAHRA)
8410         {
8411                 if (gl_fogenable.integer)
8412                 {
8413                         r_refdef.oldgl_fogenable = true;
8414                         r_refdef.fog_density = gl_fogdensity.value;
8415                         r_refdef.fog_red = gl_fogred.value;
8416                         r_refdef.fog_green = gl_foggreen.value;
8417                         r_refdef.fog_blue = gl_fogblue.value;
8418                         r_refdef.fog_alpha = 1;
8419                         r_refdef.fog_start = 0;
8420                         r_refdef.fog_end = gl_skyclip.value;
8421                         r_refdef.fog_height = 1<<30;
8422                         r_refdef.fog_fadedepth = 128;
8423                 }
8424                 else if (r_refdef.oldgl_fogenable)
8425                 {
8426                         r_refdef.oldgl_fogenable = false;
8427                         r_refdef.fog_density = 0;
8428                         r_refdef.fog_red = 0;
8429                         r_refdef.fog_green = 0;
8430                         r_refdef.fog_blue = 0;
8431                         r_refdef.fog_alpha = 0;
8432                         r_refdef.fog_start = 0;
8433                         r_refdef.fog_end = 0;
8434                         r_refdef.fog_height = 1<<30;
8435                         r_refdef.fog_fadedepth = 128;
8436                 }
8437         }
8438
8439         r_refdef.fog_alpha = bound(0, r_refdef.fog_alpha, 1);
8440         r_refdef.fog_start = max(0, r_refdef.fog_start);
8441         r_refdef.fog_end = max(r_refdef.fog_start + 0.01, r_refdef.fog_end);
8442
8443         // R_UpdateFogColor(); // why? R_RenderScene does it anyway
8444
8445         if (r_refdef.fog_density && r_drawfog.integer)
8446         {
8447                 r_refdef.fogenabled = true;
8448                 // this is the point where the fog reaches 0.9986 alpha, which we
8449                 // consider a good enough cutoff point for the texture
8450                 // (0.9986 * 256 == 255.6)
8451                 if (r_fog_exp2.integer)
8452                         r_refdef.fogrange = 32 / (r_refdef.fog_density * r_refdef.fog_density) + r_refdef.fog_start;
8453                 else
8454                         r_refdef.fogrange = 2048 / r_refdef.fog_density + r_refdef.fog_start;
8455                 r_refdef.fogrange = bound(r_refdef.fog_start, r_refdef.fogrange, r_refdef.fog_end);
8456                 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
8457                 r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
8458                 if (strcmp(r_refdef.fogheighttexturename, r_refdef.fog_height_texturename))
8459                         R_BuildFogHeightTexture();
8460                 // fog color was already set
8461                 // update the fog texture
8462                 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)
8463                         R_BuildFogTexture();
8464                 r_refdef.fog_height_texcoordscale = 1.0f / max(0.125f, r_refdef.fog_fadedepth);
8465                 r_refdef.fog_height_tablescale = r_refdef.fog_height_tablesize * r_refdef.fog_height_texcoordscale;
8466         }
8467         else
8468                 r_refdef.fogenabled = false;
8469
8470         switch(vid.renderpath)
8471         {
8472         case RENDERPATH_GL20:
8473         case RENDERPATH_CGGL:
8474                 if(v_glslgamma.integer && !vid_gammatables_trivial)
8475                 {
8476                         if(!r_texture_gammaramps || vid_gammatables_serial != r_texture_gammaramps_serial)
8477                         {
8478                                 // build GLSL gamma texture
8479 #define RAMPWIDTH 256
8480                                 unsigned short ramp[RAMPWIDTH * 3];
8481                                 unsigned char rampbgr[RAMPWIDTH][4];
8482                                 int i;
8483
8484                                 r_texture_gammaramps_serial = vid_gammatables_serial;
8485
8486                                 VID_BuildGammaTables(&ramp[0], RAMPWIDTH);
8487                                 for(i = 0; i < RAMPWIDTH; ++i)
8488                                 {
8489                                         rampbgr[i][0] = (unsigned char) (ramp[i + 2 * RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
8490                                         rampbgr[i][1] = (unsigned char) (ramp[i + RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
8491                                         rampbgr[i][2] = (unsigned char) (ramp[i] * 255.0 / 65535.0 + 0.5);
8492                                         rampbgr[i][3] = 0;
8493                                 }
8494                                 if (r_texture_gammaramps)
8495                                 {
8496                                         R_UpdateTexture(r_texture_gammaramps, &rampbgr[0][0], 0, 0, RAMPWIDTH, 1);
8497                                 }
8498                                 else
8499                                 {
8500                                         r_texture_gammaramps = R_LoadTexture2D(r_main_texturepool, "gammaramps", RAMPWIDTH, 1, &rampbgr[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT | TEXF_ALLOWUPDATES, -1, NULL);
8501                                 }
8502                         }
8503                 }
8504                 else
8505                 {
8506                         // remove GLSL gamma texture
8507                 }
8508                 break;
8509         case RENDERPATH_GL13:
8510         case RENDERPATH_GL11:
8511                 break;
8512         }
8513 }
8514
8515 static r_refdef_scene_type_t r_currentscenetype = RST_CLIENT;
8516 static r_refdef_scene_t r_scenes_store[ RST_COUNT ];
8517 /*
8518 ================
8519 R_SelectScene
8520 ================
8521 */
8522 void R_SelectScene( r_refdef_scene_type_t scenetype ) {
8523         if( scenetype != r_currentscenetype ) {
8524                 // store the old scenetype
8525                 r_scenes_store[ r_currentscenetype ] = r_refdef.scene;
8526                 r_currentscenetype = scenetype;
8527                 // move in the new scene
8528                 r_refdef.scene = r_scenes_store[ r_currentscenetype ];
8529         }
8530 }
8531
8532 /*
8533 ================
8534 R_GetScenePointer
8535 ================
8536 */
8537 r_refdef_scene_t * R_GetScenePointer( r_refdef_scene_type_t scenetype )
8538 {
8539         // of course, we could also add a qboolean that provides a lock state and a ReleaseScenePointer function..
8540         if( scenetype == r_currentscenetype ) {
8541                 return &r_refdef.scene;
8542         } else {
8543                 return &r_scenes_store[ scenetype ];
8544         }
8545 }
8546
8547 /*
8548 ================
8549 R_RenderView
8550 ================
8551 */
8552 void R_RenderView(void)
8553 {
8554         if (r_timereport_active)
8555                 R_TimeReport("start");
8556         r_textureframe++; // used only by R_GetCurrentTexture
8557         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
8558
8559         if (!r_drawentities.integer)
8560                 r_refdef.scene.numentities = 0;
8561
8562         R_AnimCache_ClearCache();
8563         R_FrameData_NewFrame();
8564
8565         if (r_refdef.view.isoverlay)
8566         {
8567                 // TODO: FIXME: move this into its own backend function maybe? [2/5/2008 Andreas]
8568                 GL_Clear( GL_DEPTH_BUFFER_BIT );
8569                 R_TimeReport("depthclear");
8570
8571                 r_refdef.view.showdebug = false;
8572
8573                 r_waterstate.enabled = false;
8574                 r_waterstate.numwaterplanes = 0;
8575
8576                 R_RenderScene();
8577
8578                 CHECKGLERROR
8579                 return;
8580         }
8581
8582         if (!r_refdef.scene.entities || r_refdef.view.width * r_refdef.view.height == 0 || !r_renderview.integer || cl_videoplaying/* || !r_refdef.scene.worldmodel*/)
8583                 return; //Host_Error ("R_RenderView: NULL worldmodel");
8584
8585         r_refdef.view.colorscale = r_hdr_scenebrightness.value;
8586
8587         R_RenderView_UpdateViewVectors();
8588
8589         R_Shadow_UpdateWorldLightSelection();
8590
8591         R_Bloom_StartFrame();
8592         R_Water_StartFrame();
8593
8594         CHECKGLERROR
8595         if (r_timereport_active)
8596                 R_TimeReport("viewsetup");
8597
8598         R_ResetViewRendering3D();
8599
8600         if (r_refdef.view.clear || r_refdef.fogenabled)
8601         {
8602                 R_ClearScreen(r_refdef.fogenabled);
8603                 if (r_timereport_active)
8604                         R_TimeReport("viewclear");
8605         }
8606         r_refdef.view.clear = true;
8607
8608         // this produces a bloom texture to be used in R_BlendView() later
8609         if (r_hdr.integer && r_bloomstate.bloomwidth)
8610         {
8611                 R_HDR_RenderBloomTexture();
8612                 // we have to bump the texture frame again because r_refdef.view.colorscale is cached in the textures
8613                 r_textureframe++; // used only by R_GetCurrentTexture
8614         }
8615
8616         r_refdef.view.showdebug = true;
8617
8618         R_View_Update();
8619         if (r_timereport_active)
8620                 R_TimeReport("visibility");
8621
8622         r_waterstate.numwaterplanes = 0;
8623         if (r_waterstate.enabled)
8624                 R_RenderWaterPlanes();
8625
8626         R_RenderScene();
8627         r_waterstate.numwaterplanes = 0;
8628
8629         R_BlendView();
8630         if (r_timereport_active)
8631                 R_TimeReport("blendview");
8632
8633         GL_Scissor(0, 0, vid.width, vid.height);
8634         GL_ScissorTest(false);
8635         CHECKGLERROR
8636 }
8637
8638 void R_RenderWaterPlanes(void)
8639 {
8640         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawAddWaterPlanes)
8641         {
8642                 r_refdef.scene.worldmodel->DrawAddWaterPlanes(r_refdef.scene.worldentity);
8643                 if (r_timereport_active)
8644                         R_TimeReport("waterworld");
8645         }
8646
8647         // don't let sound skip if going slow
8648         if (r_refdef.scene.extraupdate)
8649                 S_ExtraUpdate ();
8650
8651         R_DrawModelsAddWaterPlanes();
8652         if (r_timereport_active)
8653                 R_TimeReport("watermodels");
8654
8655         if (r_waterstate.numwaterplanes)
8656         {
8657                 R_Water_ProcessPlanes();
8658                 if (r_timereport_active)
8659                         R_TimeReport("waterscenes");
8660         }
8661 }
8662
8663 extern void R_DrawLightningBeams (void);
8664 extern void VM_CL_AddPolygonsToMeshQueue (void);
8665 extern void R_DrawPortals (void);
8666 extern cvar_t cl_locs_show;
8667 static void R_DrawLocs(void);
8668 static void R_DrawEntityBBoxes(void);
8669 static void R_DrawModelDecals(void);
8670 extern void R_DrawModelShadows(void);
8671 extern void R_DrawModelShadowMaps(void);
8672 extern cvar_t cl_decals_newsystem;
8673 extern qboolean r_shadow_usingdeferredprepass;
8674 void R_RenderScene(void)
8675 {
8676         qboolean shadowmapping = false;
8677
8678         if (r_timereport_active)
8679                 R_TimeReport("beginscene");
8680
8681         r_refdef.stats.renders++;
8682
8683         R_UpdateFogColor();
8684
8685         // don't let sound skip if going slow
8686         if (r_refdef.scene.extraupdate)
8687                 S_ExtraUpdate ();
8688
8689         R_MeshQueue_BeginScene();
8690
8691         R_SkyStartFrame();
8692
8693         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);
8694
8695         if (r_timereport_active)
8696                 R_TimeReport("skystartframe");
8697
8698         if (cl.csqc_vidvars.drawworld)
8699         {
8700                 // don't let sound skip if going slow
8701                 if (r_refdef.scene.extraupdate)
8702                         S_ExtraUpdate ();
8703
8704                 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawSky)
8705                 {
8706                         r_refdef.scene.worldmodel->DrawSky(r_refdef.scene.worldentity);
8707                         if (r_timereport_active)
8708                                 R_TimeReport("worldsky");
8709                 }
8710
8711                 if (R_DrawBrushModelsSky() && r_timereport_active)
8712                         R_TimeReport("bmodelsky");
8713
8714                 if (skyrendermasked && skyrenderlater)
8715                 {
8716                         // we have to force off the water clipping plane while rendering sky
8717                         R_SetupView(false);
8718                         R_Sky();
8719                         R_SetupView(true);
8720                         if (r_timereport_active)
8721                                 R_TimeReport("sky");
8722                 }
8723         }
8724
8725         R_AnimCache_CacheVisibleEntities();
8726         if (r_timereport_active)
8727                 R_TimeReport("animation");
8728
8729         R_Shadow_PrepareLights();
8730         if (r_shadows.integer > 0 && r_refdef.lightmapintensity > 0)
8731                 R_Shadow_PrepareModelShadows();
8732         if (r_timereport_active)
8733                 R_TimeReport("preparelights");
8734
8735         if (R_Shadow_ShadowMappingEnabled())
8736                 shadowmapping = true;
8737
8738         if (r_shadow_usingdeferredprepass)
8739                 R_Shadow_DrawPrepass();
8740
8741         if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawDepth)
8742         {
8743                 r_refdef.scene.worldmodel->DrawDepth(r_refdef.scene.worldentity);
8744                 if (r_timereport_active)
8745                         R_TimeReport("worlddepth");
8746         }
8747         if (r_depthfirst.integer >= 2)
8748         {
8749                 R_DrawModelsDepth();
8750                 if (r_timereport_active)
8751                         R_TimeReport("modeldepth");
8752         }
8753
8754         if (r_shadows.integer >= 2 && shadowmapping && r_refdef.lightmapintensity > 0)
8755         {
8756                 R_DrawModelShadowMaps();
8757                 R_ResetViewRendering3D();
8758                 // don't let sound skip if going slow
8759                 if (r_refdef.scene.extraupdate)
8760                         S_ExtraUpdate ();
8761         }
8762
8763         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->Draw)
8764         {
8765                 r_refdef.scene.worldmodel->Draw(r_refdef.scene.worldentity);
8766                 if (r_timereport_active)
8767                         R_TimeReport("world");
8768         }
8769
8770         // don't let sound skip if going slow
8771         if (r_refdef.scene.extraupdate)
8772                 S_ExtraUpdate ();
8773
8774         R_DrawModels();
8775         if (r_timereport_active)
8776                 R_TimeReport("models");
8777
8778         // don't let sound skip if going slow
8779         if (r_refdef.scene.extraupdate)
8780                 S_ExtraUpdate ();
8781
8782         if ((r_shadows.integer == 1 || (r_shadows.integer > 0 && !shadowmapping)) && !r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
8783         {
8784                 R_DrawModelShadows();
8785                 R_ResetViewRendering3D();
8786                 // don't let sound skip if going slow
8787                 if (r_refdef.scene.extraupdate)
8788                         S_ExtraUpdate ();
8789         }
8790
8791         if (!r_shadow_usingdeferredprepass)
8792         {
8793                 R_Shadow_DrawLights();
8794                 if (r_timereport_active)
8795                         R_TimeReport("rtlights");
8796         }
8797
8798         // don't let sound skip if going slow
8799         if (r_refdef.scene.extraupdate)
8800                 S_ExtraUpdate ();
8801
8802         if ((r_shadows.integer == 1 || (r_shadows.integer > 0 && !shadowmapping)) && r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
8803         {
8804                 R_DrawModelShadows();
8805                 R_ResetViewRendering3D();
8806                 // don't let sound skip if going slow
8807                 if (r_refdef.scene.extraupdate)
8808                         S_ExtraUpdate ();
8809         }
8810
8811         if (cl.csqc_vidvars.drawworld)
8812         {
8813                 if (cl_decals_newsystem.integer)
8814                 {
8815                         R_DrawModelDecals();
8816                         if (r_timereport_active)
8817                                 R_TimeReport("modeldecals");
8818                 }
8819                 else
8820                 {
8821                         R_DrawDecals();
8822                         if (r_timereport_active)
8823                                 R_TimeReport("decals");
8824                 }
8825
8826                 R_DrawParticles();
8827                 if (r_timereport_active)
8828                         R_TimeReport("particles");
8829
8830                 R_DrawExplosions();
8831                 if (r_timereport_active)
8832                         R_TimeReport("explosions");
8833
8834                 R_DrawLightningBeams();
8835                 if (r_timereport_active)
8836                         R_TimeReport("lightning");
8837         }
8838
8839         VM_CL_AddPolygonsToMeshQueue();
8840
8841         if (r_refdef.view.showdebug)
8842         {
8843                 if (cl_locs_show.integer)
8844                 {
8845                         R_DrawLocs();
8846                         if (r_timereport_active)
8847                                 R_TimeReport("showlocs");
8848                 }
8849
8850                 if (r_drawportals.integer)
8851                 {
8852                         R_DrawPortals();
8853                         if (r_timereport_active)
8854                                 R_TimeReport("portals");
8855                 }
8856
8857                 if (r_showbboxes.value > 0)
8858                 {
8859                         R_DrawEntityBBoxes();
8860                         if (r_timereport_active)
8861                                 R_TimeReport("bboxes");
8862                 }
8863         }
8864
8865         R_MeshQueue_RenderTransparent();
8866         if (r_timereport_active)
8867                 R_TimeReport("drawtrans");
8868
8869         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))
8870         {
8871                 r_refdef.scene.worldmodel->DrawDebug(r_refdef.scene.worldentity);
8872                 if (r_timereport_active)
8873                         R_TimeReport("worlddebug");
8874                 R_DrawModelsDebug();
8875                 if (r_timereport_active)
8876                         R_TimeReport("modeldebug");
8877         }
8878
8879         if (cl.csqc_vidvars.drawworld)
8880         {
8881                 R_Shadow_DrawCoronas();
8882                 if (r_timereport_active)
8883                         R_TimeReport("coronas");
8884         }
8885
8886         // don't let sound skip if going slow
8887         if (r_refdef.scene.extraupdate)
8888                 S_ExtraUpdate ();
8889
8890         R_ResetViewRendering2D();
8891 }
8892
8893 static const unsigned short bboxelements[36] =
8894 {
8895         5, 1, 3, 5, 3, 7,
8896         6, 2, 0, 6, 0, 4,
8897         7, 3, 2, 7, 2, 6,
8898         4, 0, 1, 4, 1, 5,
8899         4, 5, 7, 4, 7, 6,
8900         1, 0, 2, 1, 2, 3,
8901 };
8902
8903 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
8904 {
8905         int i;
8906         float *v, *c, f1, f2, vertex3f[8*3], color4f[8*4];
8907
8908         RSurf_ActiveWorldEntity();
8909
8910         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
8911         GL_DepthMask(false);
8912         GL_DepthRange(0, 1);
8913         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
8914         R_Mesh_ResetTextureState();
8915
8916         vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; //
8917         vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
8918         vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
8919         vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
8920         vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
8921         vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
8922         vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
8923         vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
8924         R_FillColors(color4f, 8, cr, cg, cb, ca);
8925         if (r_refdef.fogenabled)
8926         {
8927                 for (i = 0, v = vertex3f, c = color4f;i < 8;i++, v += 3, c += 4)
8928                 {
8929                         f1 = RSurf_FogVertex(v);
8930                         f2 = 1 - f1;
8931                         c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
8932                         c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
8933                         c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
8934                 }
8935         }
8936         R_Mesh_VertexPointer(vertex3f, 0, 0);
8937         R_Mesh_ColorPointer(color4f, 0, 0);
8938         R_Mesh_ResetTextureState();
8939         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8940         R_Mesh_Draw(0, 8, 0, 12, NULL, bboxelements, 0, 0);
8941 }
8942
8943 static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
8944 {
8945         int i;
8946         float color[4];
8947         prvm_edict_t *edict;
8948         prvm_prog_t *prog_save = prog;
8949
8950         // this function draws bounding boxes of server entities
8951         if (!sv.active)
8952                 return;
8953
8954         GL_CullFace(GL_NONE);
8955         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8956
8957         prog = 0;
8958         SV_VM_Begin();
8959         for (i = 0;i < numsurfaces;i++)
8960         {
8961                 edict = PRVM_EDICT_NUM(surfacelist[i]);
8962                 switch ((int)edict->fields.server->solid)
8963                 {
8964                         case SOLID_NOT:      Vector4Set(color, 1, 1, 1, 0.05);break;
8965                         case SOLID_TRIGGER:  Vector4Set(color, 1, 0, 1, 0.10);break;
8966                         case SOLID_BBOX:     Vector4Set(color, 0, 1, 0, 0.10);break;
8967                         case SOLID_SLIDEBOX: Vector4Set(color, 1, 0, 0, 0.10);break;
8968                         case SOLID_BSP:      Vector4Set(color, 0, 0, 1, 0.05);break;
8969                         default:             Vector4Set(color, 0, 0, 0, 0.50);break;
8970                 }
8971                 color[3] *= r_showbboxes.value;
8972                 color[3] = bound(0, color[3], 1);
8973                 GL_DepthTest(!r_showdisabledepthtest.integer);
8974                 GL_CullFace(r_refdef.view.cullface_front);
8975                 R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
8976         }
8977         SV_VM_End();
8978         prog = prog_save;
8979 }
8980
8981 static void R_DrawEntityBBoxes(void)
8982 {
8983         int i;
8984         prvm_edict_t *edict;
8985         vec3_t center;
8986         prvm_prog_t *prog_save = prog;
8987
8988         // this function draws bounding boxes of server entities
8989         if (!sv.active)
8990                 return;
8991
8992         prog = 0;
8993         SV_VM_Begin();
8994         for (i = 0;i < prog->num_edicts;i++)
8995         {
8996                 edict = PRVM_EDICT_NUM(i);
8997                 if (edict->priv.server->free)
8998                         continue;
8999                 // exclude the following for now, as they don't live in world coordinate space and can't be solid:
9000                 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.tag_entity)->edict != 0)
9001                         continue;
9002                 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.viewmodelforclient)->edict != 0)
9003                         continue;
9004                 VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
9005                 R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
9006         }
9007         SV_VM_End();
9008         prog = prog_save;
9009 }
9010
9011 static const int nomodelelement3i[24] =
9012 {
9013         5, 2, 0,
9014         5, 1, 2,
9015         5, 0, 3,
9016         5, 3, 1,
9017         0, 2, 4,
9018         2, 1, 4,
9019         3, 0, 4,
9020         1, 3, 4
9021 };
9022
9023 static const unsigned short nomodelelement3s[24] =
9024 {
9025         5, 2, 0,
9026         5, 1, 2,
9027         5, 0, 3,
9028         5, 3, 1,
9029         0, 2, 4,
9030         2, 1, 4,
9031         3, 0, 4,
9032         1, 3, 4
9033 };
9034
9035 static const float nomodelvertex3f[6*3] =
9036 {
9037         -16,   0,   0,
9038          16,   0,   0,
9039           0, -16,   0,
9040           0,  16,   0,
9041           0,   0, -16,
9042           0,   0,  16
9043 };
9044
9045 static const float nomodelcolor4f[6*4] =
9046 {
9047         0.0f, 0.0f, 0.5f, 1.0f,
9048         0.0f, 0.0f, 0.5f, 1.0f,
9049         0.0f, 0.5f, 0.0f, 1.0f,
9050         0.0f, 0.5f, 0.0f, 1.0f,
9051         0.5f, 0.0f, 0.0f, 1.0f,
9052         0.5f, 0.0f, 0.0f, 1.0f
9053 };
9054
9055 void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
9056 {
9057         int i;
9058         float f1, f2, *c;
9059         float color4f[6*4];
9060
9061         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);
9062
9063         // this is only called once per entity so numsurfaces is always 1, and
9064         // surfacelist is always {0}, so this code does not handle batches
9065
9066         if (rsurface.ent_flags & RENDER_ADDITIVE)
9067         {
9068                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
9069                 GL_DepthMask(false);
9070         }
9071         else if (rsurface.colormod[3] < 1)
9072         {
9073                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9074                 GL_DepthMask(false);
9075         }
9076         else
9077         {
9078                 GL_BlendFunc(GL_ONE, GL_ZERO);
9079                 GL_DepthMask(true);
9080         }
9081         GL_DepthRange(0, (rsurface.ent_flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
9082         GL_PolygonOffset(rsurface.basepolygonfactor, rsurface.basepolygonoffset);
9083         GL_DepthTest(!(rsurface.ent_flags & RENDER_NODEPTHTEST));
9084         GL_CullFace((rsurface.ent_flags & RENDER_DOUBLESIDED) ? GL_NONE : r_refdef.view.cullface_back);
9085         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9086         R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
9087         memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
9088         R_Mesh_ColorPointer(color4f, 0, 0);
9089         for (i = 0, c = color4f;i < 6;i++, c += 4)
9090         {
9091                 c[0] *= rsurface.colormod[0];
9092                 c[1] *= rsurface.colormod[1];
9093                 c[2] *= rsurface.colormod[2];
9094                 c[3] *= rsurface.colormod[3];
9095         }
9096         if (r_refdef.fogenabled)
9097         {
9098                 for (i = 0, c = color4f;i < 6;i++, c += 4)
9099                 {
9100                         f1 = RSurf_FogVertex(rsurface.vertex3f + 3*i);
9101                         f2 = 1 - f1;
9102                         c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
9103                         c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
9104                         c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
9105                 }
9106         }
9107         R_Mesh_ResetTextureState();
9108         R_Mesh_Draw(0, 6, 0, 8, nomodelelement3i, nomodelelement3s, 0, 0);
9109 }
9110
9111 void R_DrawNoModel(entity_render_t *ent)
9112 {
9113         vec3_t org;
9114         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
9115         if ((ent->flags & RENDER_ADDITIVE) || (ent->alpha < 1))
9116                 R_MeshQueue_AddTransparent(ent->flags & RENDER_NODEPTHTEST ? r_refdef.view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
9117         else
9118                 R_DrawNoModel_TransparentCallback(ent, rsurface.rtlight, 0, NULL);
9119 }
9120
9121 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
9122 {
9123         vec3_t right1, right2, diff, normal;
9124
9125         VectorSubtract (org2, org1, normal);
9126
9127         // calculate 'right' vector for start
9128         VectorSubtract (r_refdef.view.origin, org1, diff);
9129         CrossProduct (normal, diff, right1);
9130         VectorNormalize (right1);
9131
9132         // calculate 'right' vector for end
9133         VectorSubtract (r_refdef.view.origin, org2, diff);
9134         CrossProduct (normal, diff, right2);
9135         VectorNormalize (right2);
9136
9137         vert[ 0] = org1[0] + width * right1[0];
9138         vert[ 1] = org1[1] + width * right1[1];
9139         vert[ 2] = org1[2] + width * right1[2];
9140         vert[ 3] = org1[0] - width * right1[0];
9141         vert[ 4] = org1[1] - width * right1[1];
9142         vert[ 5] = org1[2] - width * right1[2];
9143         vert[ 6] = org2[0] - width * right2[0];
9144         vert[ 7] = org2[1] - width * right2[1];
9145         vert[ 8] = org2[2] - width * right2[2];
9146         vert[ 9] = org2[0] + width * right2[0];
9147         vert[10] = org2[1] + width * right2[1];
9148         vert[11] = org2[2] + width * right2[2];
9149 }
9150
9151 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)
9152 {
9153         vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
9154         vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
9155         vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
9156         vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
9157         vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
9158         vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
9159         vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
9160         vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
9161         vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
9162         vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
9163         vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
9164         vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
9165 }
9166
9167 int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
9168 {
9169         int i;
9170         float *vertex3f;
9171         float v[3];
9172         VectorSet(v, x, y, z);
9173         for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
9174                 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
9175                         break;
9176         if (i == mesh->numvertices)
9177         {
9178                 if (mesh->numvertices < mesh->maxvertices)
9179                 {
9180                         VectorCopy(v, vertex3f);
9181                         mesh->numvertices++;
9182                 }
9183                 return mesh->numvertices;
9184         }
9185         else
9186                 return i;
9187 }
9188
9189 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
9190 {
9191         int i;
9192         int *e, element[3];
9193         element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
9194         element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
9195         e = mesh->element3i + mesh->numtriangles * 3;
9196         for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
9197         {
9198                 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
9199                 if (mesh->numtriangles < mesh->maxtriangles)
9200                 {
9201                         *e++ = element[0];
9202                         *e++ = element[1];
9203                         *e++ = element[2];
9204                         mesh->numtriangles++;
9205                 }
9206                 element[1] = element[2];
9207         }
9208 }
9209
9210 void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
9211 {
9212         int i;
9213         int *e, element[3];
9214         element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
9215         element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
9216         e = mesh->element3i + mesh->numtriangles * 3;
9217         for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
9218         {
9219                 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
9220                 if (mesh->numtriangles < mesh->maxtriangles)
9221                 {
9222                         *e++ = element[0];
9223                         *e++ = element[1];
9224                         *e++ = element[2];
9225                         mesh->numtriangles++;
9226                 }
9227                 element[1] = element[2];
9228         }
9229 }
9230
9231 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
9232 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
9233 {
9234         int planenum, planenum2;
9235         int w;
9236         int tempnumpoints;
9237         mplane_t *plane, *plane2;
9238         double maxdist;
9239         double temppoints[2][256*3];
9240         // figure out how large a bounding box we need to properly compute this brush
9241         maxdist = 0;
9242         for (w = 0;w < numplanes;w++)
9243                 maxdist = max(maxdist, fabs(planes[w].dist));
9244         // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
9245         maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
9246         for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
9247         {
9248                 w = 0;
9249                 tempnumpoints = 4;
9250                 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
9251                 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
9252                 {
9253                         if (planenum2 == planenum)
9254                                 continue;
9255                         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);
9256                         w = !w;
9257                 }
9258                 if (tempnumpoints < 3)
9259                         continue;
9260                 // generate elements forming a triangle fan for this polygon
9261                 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
9262         }
9263 }
9264
9265 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)
9266 {
9267         texturelayer_t *layer;
9268         layer = t->currentlayers + t->currentnumlayers++;
9269         layer->type = type;
9270         layer->depthmask = depthmask;
9271         layer->blendfunc1 = blendfunc1;
9272         layer->blendfunc2 = blendfunc2;
9273         layer->texture = texture;
9274         layer->texmatrix = *matrix;
9275         layer->color[0] = r;
9276         layer->color[1] = g;
9277         layer->color[2] = b;
9278         layer->color[3] = a;
9279 }
9280
9281 static qboolean R_TestQ3WaveFunc(q3wavefunc_t func, const float *parms)
9282 {
9283         if(parms[0] == 0 && parms[1] == 0)
9284                 return false;
9285         if(func >> Q3WAVEFUNC_USER_SHIFT) // assumes rsurface to be set!
9286                 if(rsurface.userwavefunc_param[bound(0, (func >> Q3WAVEFUNC_USER_SHIFT) - 1, Q3WAVEFUNC_USER_COUNT)] == 0)
9287                         return false;
9288         return true;
9289 }
9290
9291 static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
9292 {
9293         double index, f;
9294         index = parms[2] + r_refdef.scene.time * parms[3];
9295         index -= floor(index);
9296         switch (func & ((1 << Q3WAVEFUNC_USER_SHIFT) - 1))
9297         {
9298         default:
9299         case Q3WAVEFUNC_NONE:
9300         case Q3WAVEFUNC_NOISE:
9301         case Q3WAVEFUNC_COUNT:
9302                 f = 0;
9303                 break;
9304         case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
9305         case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
9306         case Q3WAVEFUNC_SAWTOOTH: f = index;break;
9307         case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
9308         case Q3WAVEFUNC_TRIANGLE:
9309                 index *= 4;
9310                 f = index - floor(index);
9311                 if (index < 1)
9312                         f = f;
9313                 else if (index < 2)
9314                         f = 1 - f;
9315                 else if (index < 3)
9316                         f = -f;
9317                 else
9318                         f = -(1 - f);
9319                 break;
9320         }
9321         f = parms[0] + parms[1] * f;
9322         if(func >> Q3WAVEFUNC_USER_SHIFT) // assumes rsurface to be set!
9323                 f *= rsurface.userwavefunc_param[bound(0, (func >> Q3WAVEFUNC_USER_SHIFT) - 1, Q3WAVEFUNC_USER_COUNT)];
9324         return (float) f;
9325 }
9326
9327 void R_tcMod_ApplyToMatrix(matrix4x4_t *texmatrix, q3shaderinfo_layer_tcmod_t *tcmod, int currentmaterialflags)
9328 {
9329         int w, h, idx;
9330         float f;
9331         float tcmat[12];
9332         matrix4x4_t matrix, temp;
9333         switch(tcmod->tcmod)
9334         {
9335                 case Q3TCMOD_COUNT:
9336                 case Q3TCMOD_NONE:
9337                         if (currentmaterialflags & MATERIALFLAG_WATERSCROLL)
9338                                 matrix = r_waterscrollmatrix;
9339                         else
9340                                 matrix = identitymatrix;
9341                         break;
9342                 case Q3TCMOD_ENTITYTRANSLATE:
9343                         // this is used in Q3 to allow the gamecode to control texcoord
9344                         // scrolling on the entity, which is not supported in darkplaces yet.
9345                         Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
9346                         break;
9347                 case Q3TCMOD_ROTATE:
9348                         Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
9349                         Matrix4x4_ConcatRotate(&matrix, tcmod->parms[0] * r_refdef.scene.time, 0, 0, 1);
9350                         Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
9351                         break;
9352                 case Q3TCMOD_SCALE:
9353                         Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
9354                         break;
9355                 case Q3TCMOD_SCROLL:
9356                         Matrix4x4_CreateTranslate(&matrix, tcmod->parms[0] * r_refdef.scene.time, tcmod->parms[1] * r_refdef.scene.time, 0);
9357                         break;
9358                 case Q3TCMOD_PAGE: // poor man's animmap (to store animations into a single file, useful for HTTP downloaded textures)
9359                         w = (int) tcmod->parms[0];
9360                         h = (int) tcmod->parms[1];
9361                         f = r_refdef.scene.time / (tcmod->parms[2] * w * h);
9362                         f = f - floor(f);
9363                         idx = (int) floor(f * w * h);
9364                         Matrix4x4_CreateTranslate(&matrix, (idx % w) / tcmod->parms[0], (idx / w) / tcmod->parms[1], 0);
9365                         break;
9366                 case Q3TCMOD_STRETCH:
9367                         f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
9368                         Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
9369                         break;
9370                 case Q3TCMOD_TRANSFORM:
9371                         VectorSet(tcmat +  0, tcmod->parms[0], tcmod->parms[1], 0);
9372                         VectorSet(tcmat +  3, tcmod->parms[2], tcmod->parms[3], 0);
9373                         VectorSet(tcmat +  6, 0                   , 0                , 1);
9374                         VectorSet(tcmat +  9, tcmod->parms[4], tcmod->parms[5], 0);
9375                         Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
9376                         break;
9377                 case Q3TCMOD_TURBULENT:
9378                         // this is handled in the RSurf_PrepareVertices function
9379                         matrix = identitymatrix;
9380                         break;
9381         }
9382         temp = *texmatrix;
9383         Matrix4x4_Concat(texmatrix, &matrix, &temp);
9384 }
9385
9386 void R_LoadQWSkin(r_qwskincache_t *cache, const char *skinname)
9387 {
9388         int textureflags = (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_PICMIP | TEXF_COMPRESS;
9389         char name[MAX_QPATH];
9390         skinframe_t *skinframe;
9391         unsigned char pixels[296*194];
9392         strlcpy(cache->name, skinname, sizeof(cache->name));
9393         dpsnprintf(name, sizeof(name), "skins/%s.pcx", cache->name);
9394         if (developer_loading.integer)
9395                 Con_Printf("loading %s\n", name);
9396         skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
9397         if (!skinframe || !skinframe->base)
9398         {
9399                 unsigned char *f;
9400                 fs_offset_t filesize;
9401                 skinframe = NULL;
9402                 f = FS_LoadFile(name, tempmempool, true, &filesize);
9403                 if (f)
9404                 {
9405                         if (LoadPCX_QWSkin(f, (int)filesize, pixels, 296, 194))
9406                                 skinframe = R_SkinFrame_LoadInternalQuake(name, textureflags, true, r_fullbrights.integer, pixels, image_width, image_height);
9407                         Mem_Free(f);
9408                 }
9409         }
9410         cache->skinframe = skinframe;
9411 }
9412
9413 texture_t *R_GetCurrentTexture(texture_t *t)
9414 {
9415         int i;
9416         const entity_render_t *ent = rsurface.entity;
9417         dp_model_t *model = ent->model;
9418         q3shaderinfo_layer_tcmod_t *tcmod;
9419
9420         if (t->update_lastrenderframe == r_textureframe && t->update_lastrenderentity == (void *)ent)
9421                 return t->currentframe;
9422         t->update_lastrenderframe = r_textureframe;
9423         t->update_lastrenderentity = (void *)ent;
9424
9425         if(ent && ent->entitynumber >= MAX_EDICTS && ent->entitynumber < 2 * MAX_EDICTS)
9426                 t->camera_entity = ent->entitynumber;
9427         else
9428                 t->camera_entity = 0;
9429
9430         // switch to an alternate material if this is a q1bsp animated material
9431         {
9432                 texture_t *texture = t;
9433                 int s = rsurface.ent_skinnum;
9434                 if ((unsigned int)s >= (unsigned int)model->numskins)
9435                         s = 0;
9436                 if (model->skinscenes)
9437                 {
9438                         if (model->skinscenes[s].framecount > 1)
9439                                 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.scene.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
9440                         else
9441                                 s = model->skinscenes[s].firstframe;
9442                 }
9443                 if (s > 0)
9444                         t = t + s * model->num_surfaces;
9445                 if (t->animated)
9446                 {
9447                         // use an alternate animation if the entity's frame is not 0,
9448                         // and only if the texture has an alternate animation
9449                         if (rsurface.ent_alttextures && t->anim_total[1])
9450                                 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[1]) : 0];
9451                         else
9452                                 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[0]) : 0];
9453                 }
9454                 texture->currentframe = t;
9455         }
9456
9457         // update currentskinframe to be a qw skin or animation frame
9458         if (rsurface.ent_qwskin >= 0)
9459         {
9460                 i = rsurface.ent_qwskin;
9461                 if (!r_qwskincache || r_qwskincache_size != cl.maxclients)
9462                 {
9463                         r_qwskincache_size = cl.maxclients;
9464                         if (r_qwskincache)
9465                                 Mem_Free(r_qwskincache);
9466                         r_qwskincache = Mem_Alloc(r_main_mempool, sizeof(*r_qwskincache) * r_qwskincache_size);
9467                 }
9468                 if (strcmp(r_qwskincache[i].name, cl.scores[i].qw_skin))
9469                         R_LoadQWSkin(&r_qwskincache[i], cl.scores[i].qw_skin);
9470                 t->currentskinframe = r_qwskincache[i].skinframe;
9471                 if (t->currentskinframe == NULL)
9472                         t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
9473         }
9474         else if (t->numskinframes >= 2)
9475                 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
9476         if (t->backgroundnumskinframes >= 2)
9477                 t->backgroundcurrentskinframe = t->backgroundskinframes[(int)(t->backgroundskinframerate * (cl.time - rsurface.ent_shadertime)) % t->backgroundnumskinframes];
9478
9479         t->currentmaterialflags = t->basematerialflags;
9480         t->currentalpha = rsurface.colormod[3];
9481         if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
9482                 t->currentalpha *= r_wateralpha.value;
9483         if(t->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay)
9484                 t->currentalpha *= t->r_water_wateralpha;
9485         if(!r_waterstate.enabled || r_refdef.view.isoverlay)
9486                 t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA);
9487         if (!(rsurface.ent_flags & RENDER_LIGHT))
9488                 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
9489         else if (rsurface.modeltexcoordlightmap2f == NULL && !(t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
9490         {
9491                 // pick a model lighting mode
9492                 if (VectorLength2(rsurface.modellight_diffuse) >= (1.0f / 256.0f))
9493                         t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
9494                 else
9495                         t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
9496         }
9497         if (rsurface.ent_flags & RENDER_ADDITIVE)
9498                 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
9499         else if (t->currentalpha < 1)
9500                 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
9501         if (rsurface.ent_flags & RENDER_DOUBLESIDED)
9502                 t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
9503         if (rsurface.ent_flags & (RENDER_NODEPTHTEST | RENDER_VIEWMODEL))
9504                 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
9505         if (t->backgroundnumskinframes)
9506                 t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
9507         if (t->currentmaterialflags & MATERIALFLAG_BLENDED)
9508         {
9509                 if (t->currentmaterialflags & (MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER | MATERIALFLAG_CAMERA))
9510                         t->currentmaterialflags &= ~MATERIALFLAG_BLENDED;
9511         }
9512         else
9513                 t->currentmaterialflags &= ~(MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER | MATERIALFLAG_CAMERA);
9514         if ((t->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST)) == MATERIALFLAG_BLENDED && r_transparentdepthmasking.integer && !(t->basematerialflags & MATERIALFLAG_BLENDED))
9515                 t->currentmaterialflags |= MATERIALFLAG_TRANSDEPTH;
9516
9517         // there is no tcmod
9518         if (t->currentmaterialflags & MATERIALFLAG_WATERSCROLL)
9519         {
9520                 t->currenttexmatrix = r_waterscrollmatrix;
9521                 t->currentbackgroundtexmatrix = r_waterscrollmatrix;
9522         }
9523         else if (!(t->currentmaterialflags & MATERIALFLAG_CUSTOMSURFACE))
9524         {
9525                 Matrix4x4_CreateIdentity(&t->currenttexmatrix);
9526                 Matrix4x4_CreateIdentity(&t->currentbackgroundtexmatrix);
9527         }
9528
9529         for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
9530                 R_tcMod_ApplyToMatrix(&t->currenttexmatrix, tcmod, t->currentmaterialflags);
9531         for (i = 0, tcmod = t->backgroundtcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
9532                 R_tcMod_ApplyToMatrix(&t->currentbackgroundtexmatrix, tcmod, t->currentmaterialflags);
9533
9534         t->colormapping = VectorLength2(rsurface.colormap_pantscolor) + VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f);
9535         if (t->currentskinframe->qpixels)
9536                 R_SkinFrame_GenerateTexturesFromQPixels(t->currentskinframe, t->colormapping);
9537         t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
9538         if (!t->basetexture)
9539                 t->basetexture = r_texture_notexture;
9540         t->pantstexture = t->colormapping ? t->currentskinframe->pants : NULL;
9541         t->shirttexture = t->colormapping ? t->currentskinframe->shirt : NULL;
9542         t->nmaptexture = t->currentskinframe->nmap;
9543         if (!t->nmaptexture)
9544                 t->nmaptexture = r_texture_blanknormalmap;
9545         t->glosstexture = r_texture_black;
9546         t->glowtexture = t->currentskinframe->glow;
9547         t->fogtexture = t->currentskinframe->fog;
9548         t->reflectmasktexture = t->currentskinframe->reflect;
9549         if (t->backgroundnumskinframes)
9550         {
9551                 t->backgroundbasetexture = (!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base;
9552                 t->backgroundnmaptexture = t->backgroundcurrentskinframe->nmap;
9553                 t->backgroundglosstexture = r_texture_black;
9554                 t->backgroundglowtexture = t->backgroundcurrentskinframe->glow;
9555                 if (!t->backgroundnmaptexture)
9556                         t->backgroundnmaptexture = r_texture_blanknormalmap;
9557         }
9558         else
9559         {
9560                 t->backgroundbasetexture = t->backgroundnumskinframes ? ((!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base) : r_texture_white;
9561                 t->backgroundnmaptexture = r_texture_blanknormalmap;
9562                 t->backgroundglosstexture = r_texture_black;
9563                 t->backgroundglowtexture = NULL;
9564         }
9565         t->specularpower = r_shadow_glossexponent.value;
9566         // TODO: store reference values for these in the texture?
9567         t->specularscale = 0;
9568         if (r_shadow_gloss.integer > 0)
9569         {
9570                 if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
9571                 {
9572                         if (r_shadow_glossintensity.value > 0)
9573                         {
9574                                 t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
9575                                 t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
9576                                 t->specularscale = r_shadow_glossintensity.value;
9577                         }
9578                 }
9579                 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
9580                 {
9581                         t->glosstexture = r_texture_white;
9582                         t->backgroundglosstexture = r_texture_white;
9583                         t->specularscale = r_shadow_gloss2intensity.value;
9584                         t->specularpower = r_shadow_gloss2exponent.value;
9585                 }
9586         }
9587         t->specularscale *= t->specularscalemod;
9588         t->specularpower *= t->specularpowermod;
9589
9590         // lightmaps mode looks bad with dlights using actual texturing, so turn
9591         // off the colormap and glossmap, but leave the normalmap on as it still
9592         // accurately represents the shading involved
9593         if (gl_lightmaps.integer)
9594         {
9595                 t->basetexture = r_texture_grey128;
9596                 t->pantstexture = r_texture_black;
9597                 t->shirttexture = r_texture_black;
9598                 t->nmaptexture = r_texture_blanknormalmap;
9599                 t->glosstexture = r_texture_black;
9600                 t->glowtexture = NULL;
9601                 t->fogtexture = NULL;
9602                 t->reflectmasktexture = NULL;
9603                 t->backgroundbasetexture = NULL;
9604                 t->backgroundnmaptexture = r_texture_blanknormalmap;
9605                 t->backgroundglosstexture = r_texture_black;
9606                 t->backgroundglowtexture = NULL;
9607                 t->specularscale = 0;
9608                 t->currentmaterialflags = MATERIALFLAG_WALL | (t->currentmaterialflags & (MATERIALFLAG_NOCULLFACE | MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SHORTDEPTHRANGE));
9609         }
9610
9611         Vector4Set(t->lightmapcolor, rsurface.colormod[0], rsurface.colormod[1], rsurface.colormod[2], t->currentalpha);
9612         VectorClear(t->dlightcolor);
9613         t->currentnumlayers = 0;
9614         if (t->currentmaterialflags & MATERIALFLAG_WALL)
9615         {
9616                 int blendfunc1, blendfunc2;
9617                 qboolean depthmask;
9618                 if (t->currentmaterialflags & MATERIALFLAG_ADD)
9619                 {
9620                         blendfunc1 = GL_SRC_ALPHA;
9621                         blendfunc2 = GL_ONE;
9622                 }
9623                 else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
9624                 {
9625                         blendfunc1 = GL_SRC_ALPHA;
9626                         blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
9627                 }
9628                 else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
9629                 {
9630                         blendfunc1 = t->customblendfunc[0];
9631                         blendfunc2 = t->customblendfunc[1];
9632                 }
9633                 else
9634                 {
9635                         blendfunc1 = GL_ONE;
9636                         blendfunc2 = GL_ZERO;
9637                 }
9638                 // don't colormod evilblend textures
9639                 if(!R_BlendFuncAllowsColormod(blendfunc1, blendfunc2))
9640                         VectorSet(t->lightmapcolor, 1, 1, 1);
9641                 depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
9642                 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
9643                 {
9644                         // fullbright is not affected by r_refdef.lightmapintensity
9645                         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]);
9646                         if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
9647                                 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]);
9648                         if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
9649                                 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]);
9650                 }
9651                 else
9652                 {
9653                         vec3_t ambientcolor;
9654                         float colorscale;
9655                         // set the color tint used for lights affecting this surface
9656                         VectorSet(t->dlightcolor, t->lightmapcolor[0] * t->lightmapcolor[3], t->lightmapcolor[1] * t->lightmapcolor[3], t->lightmapcolor[2] * t->lightmapcolor[3]);
9657                         colorscale = 2;
9658                         // q3bsp has no lightmap updates, so the lightstylevalue that
9659                         // would normally be baked into the lightmap must be
9660                         // applied to the color
9661                         // FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
9662                         if (model->type == mod_brushq3)
9663                                 colorscale *= r_refdef.scene.rtlightstylevalue[0];
9664                         colorscale *= r_refdef.lightmapintensity;
9665                         VectorScale(t->lightmapcolor, r_refdef.scene.ambient, ambientcolor);
9666                         VectorScale(t->lightmapcolor, colorscale, t->lightmapcolor);
9667                         // basic lit geometry
9668                         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]);
9669                         // add pants/shirt if needed
9670                         if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
9671                                 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]);
9672                         if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
9673                                 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]);
9674                         // now add ambient passes if needed
9675                         if (VectorLength2(ambientcolor) >= (1.0f/1048576.0f))
9676                         {
9677                                 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]);
9678                                 if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
9679                                         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]);
9680                                 if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
9681                                         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]);
9682                         }
9683                 }
9684                 if (t->glowtexture != NULL && !gl_lightmaps.integer)
9685                         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]);
9686                 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
9687                 {
9688                         // if this is opaque use alpha blend which will darken the earlier
9689                         // passes cheaply.
9690                         //
9691                         // if this is an alpha blended material, all the earlier passes
9692                         // were darkened by fog already, so we only need to add the fog
9693                         // color ontop through the fog mask texture
9694                         //
9695                         // if this is an additive blended material, all the earlier passes
9696                         // were darkened by fog already, and we should not add fog color
9697                         // (because the background was not darkened, there is no fog color
9698                         // that was lost behind it).
9699                         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]);
9700                 }
9701         }
9702
9703         return t->currentframe;
9704 }
9705
9706 rsurfacestate_t rsurface;
9707
9708 void R_Mesh_ResizeArrays(int newvertices)
9709 {
9710         float *base;
9711         if (rsurface.array_size >= newvertices)
9712                 return;
9713         if (rsurface.array_modelvertex3f)
9714                 Mem_Free(rsurface.array_modelvertex3f);
9715         rsurface.array_size = (newvertices + 1023) & ~1023;
9716         base = (float *)Mem_Alloc(r_main_mempool, rsurface.array_size * sizeof(float[33]));
9717         rsurface.array_modelvertex3f     = base + rsurface.array_size * 0;
9718         rsurface.array_modelsvector3f    = base + rsurface.array_size * 3;
9719         rsurface.array_modeltvector3f    = base + rsurface.array_size * 6;
9720         rsurface.array_modelnormal3f     = base + rsurface.array_size * 9;
9721         rsurface.array_deformedvertex3f  = base + rsurface.array_size * 12;
9722         rsurface.array_deformedsvector3f = base + rsurface.array_size * 15;
9723         rsurface.array_deformedtvector3f = base + rsurface.array_size * 18;
9724         rsurface.array_deformednormal3f  = base + rsurface.array_size * 21;
9725         rsurface.array_texcoord3f        = base + rsurface.array_size * 24;
9726         rsurface.array_color4f           = base + rsurface.array_size * 27;
9727         rsurface.array_generatedtexcoordtexture2f = base + rsurface.array_size * 31;
9728 }
9729
9730 void RSurf_ActiveWorldEntity(void)
9731 {
9732         dp_model_t *model = r_refdef.scene.worldmodel;
9733         //if (rsurface.entity == r_refdef.scene.worldentity)
9734         //      return;
9735         rsurface.entity = r_refdef.scene.worldentity;
9736         rsurface.skeleton = NULL;
9737         memset(rsurface.userwavefunc_param, 0, sizeof(rsurface.userwavefunc_param));
9738         rsurface.ent_skinnum = 0;
9739         rsurface.ent_qwskin = -1;
9740         rsurface.ent_shadertime = 0;
9741         rsurface.ent_flags = r_refdef.scene.worldentity->flags;
9742         if (rsurface.array_size < model->surfmesh.num_vertices)
9743                 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
9744         rsurface.matrix = identitymatrix;
9745         rsurface.inversematrix = identitymatrix;
9746         rsurface.matrixscale = 1;
9747         rsurface.inversematrixscale = 1;
9748         R_EntityMatrix(&identitymatrix);
9749         VectorCopy(r_refdef.view.origin, rsurface.localvieworigin);
9750         Vector4Copy(r_refdef.fogplane, rsurface.fogplane);
9751         rsurface.fograngerecip = r_refdef.fograngerecip;
9752         rsurface.fogheightfade = r_refdef.fogheightfade;
9753         rsurface.fogplaneviewdist = r_refdef.fogplaneviewdist;
9754         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
9755         VectorSet(rsurface.modellight_ambient, 0, 0, 0);
9756         VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
9757         VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
9758         VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
9759         VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
9760         VectorSet(rsurface.colormod, r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale);
9761         rsurface.colormod[3] = 1;
9762         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);
9763         memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
9764         rsurface.frameblend[0].lerp = 1;
9765         rsurface.ent_alttextures = false;
9766         rsurface.basepolygonfactor = r_refdef.polygonfactor;
9767         rsurface.basepolygonoffset = r_refdef.polygonoffset;
9768         rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
9769         rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
9770         rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
9771         rsurface.modelsvector3f = model->surfmesh.data_svector3f;
9772         rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
9773         rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
9774         rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
9775         rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
9776         rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
9777         rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
9778         rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
9779         rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
9780         rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
9781         rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
9782         rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
9783         rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
9784         rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
9785         rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
9786         rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
9787         rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
9788         rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
9789         rsurface.modelelement3i = model->surfmesh.data_element3i;
9790         rsurface.modelelement3s = model->surfmesh.data_element3s;
9791         rsurface.modelelement3i_bufferobject = model->surfmesh.ebo3i;
9792         rsurface.modelelement3s_bufferobject = model->surfmesh.ebo3s;
9793         rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
9794         rsurface.modelnum_vertices = model->surfmesh.num_vertices;
9795         rsurface.modelnum_triangles = model->surfmesh.num_triangles;
9796         rsurface.modelsurfaces = model->data_surfaces;
9797         rsurface.generatedvertex = false;
9798         rsurface.vertex3f  = rsurface.modelvertex3f;
9799         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
9800         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
9801         rsurface.svector3f = rsurface.modelsvector3f;
9802         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
9803         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
9804         rsurface.tvector3f = rsurface.modeltvector3f;
9805         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
9806         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
9807         rsurface.normal3f  = rsurface.modelnormal3f;
9808         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
9809         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
9810         rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
9811 }
9812
9813 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents, qboolean prepass)
9814 {
9815         dp_model_t *model = ent->model;
9816         //if (rsurface.entity == ent && (!model->surfmesh.isanimated || (!wantnormals && !wanttangents)))
9817         //      return;
9818         rsurface.entity = (entity_render_t *)ent;
9819         rsurface.skeleton = ent->skeleton;
9820         memcpy(rsurface.userwavefunc_param, ent->userwavefunc_param, sizeof(rsurface.userwavefunc_param));
9821         rsurface.ent_skinnum = ent->skinnum;
9822         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;
9823         rsurface.ent_shadertime = ent->shadertime;
9824         rsurface.ent_flags = ent->flags;
9825         if (rsurface.array_size < model->surfmesh.num_vertices)
9826                 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
9827         rsurface.matrix = ent->matrix;
9828         rsurface.inversematrix = ent->inversematrix;
9829         rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
9830         rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
9831         R_EntityMatrix(&rsurface.matrix);
9832         Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
9833         Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
9834         rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
9835         rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
9836         rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
9837         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
9838         VectorCopy(ent->modellight_ambient, rsurface.modellight_ambient);
9839         VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
9840         VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
9841         VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
9842         VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
9843         VectorScale(ent->colormod, r_refdef.view.colorscale, rsurface.colormod);
9844         rsurface.colormod[3] = ent->alpha;
9845         VectorScale(ent->glowmod, r_refdef.view.colorscale * r_hdr_glowintensity.value, rsurface.glowmod);
9846         memcpy(rsurface.frameblend, ent->frameblend, sizeof(ent->frameblend));
9847         rsurface.ent_alttextures = ent->framegroupblend[0].frame != 0;
9848         rsurface.basepolygonfactor = r_refdef.polygonfactor;
9849         rsurface.basepolygonoffset = r_refdef.polygonoffset;
9850         if (ent->model->brush.submodel && !prepass)
9851         {
9852                 rsurface.basepolygonfactor += r_polygonoffset_submodel_factor.value;
9853                 rsurface.basepolygonoffset += r_polygonoffset_submodel_offset.value;
9854         }
9855         if (model->surfmesh.isanimated && model->AnimateVertices && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].subframe != 0))
9856         {
9857                 if (ent->animcache_vertex3f && !r_framedata_failed)
9858                 {
9859                         rsurface.modelvertex3f = ent->animcache_vertex3f;
9860                         rsurface.modelsvector3f = wanttangents ? ent->animcache_svector3f : NULL;
9861                         rsurface.modeltvector3f = wanttangents ? ent->animcache_tvector3f : NULL;
9862                         rsurface.modelnormal3f = wantnormals ? ent->animcache_normal3f : NULL;
9863                 }
9864                 else if (wanttangents)
9865                 {
9866                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
9867                         rsurface.modelsvector3f = rsurface.array_modelsvector3f;
9868                         rsurface.modeltvector3f = rsurface.array_modeltvector3f;
9869                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
9870                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f);
9871                 }
9872                 else if (wantnormals)
9873                 {
9874                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
9875                         rsurface.modelsvector3f = NULL;
9876                         rsurface.modeltvector3f = NULL;
9877                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
9878                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL);
9879                 }
9880                 else
9881                 {
9882                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
9883                         rsurface.modelsvector3f = NULL;
9884                         rsurface.modeltvector3f = NULL;
9885                         rsurface.modelnormal3f = NULL;
9886                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, NULL, NULL, NULL);
9887                 }
9888                 rsurface.modelvertex3f_bufferobject = 0;
9889                 rsurface.modelvertex3f_bufferoffset = 0;
9890                 rsurface.modelsvector3f_bufferobject = 0;
9891                 rsurface.modelsvector3f_bufferoffset = 0;
9892                 rsurface.modeltvector3f_bufferobject = 0;
9893                 rsurface.modeltvector3f_bufferoffset = 0;
9894                 rsurface.modelnormal3f_bufferobject = 0;
9895                 rsurface.modelnormal3f_bufferoffset = 0;
9896                 rsurface.generatedvertex = true;
9897         }
9898         else
9899         {
9900                 rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
9901                 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
9902                 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
9903                 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
9904                 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
9905                 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
9906                 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
9907                 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
9908                 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
9909                 rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
9910                 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
9911                 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
9912                 rsurface.generatedvertex = false;
9913         }
9914         rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
9915         rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
9916         rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
9917         rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
9918         rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
9919         rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
9920         rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
9921         rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
9922         rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
9923         rsurface.modelelement3i = model->surfmesh.data_element3i;
9924         rsurface.modelelement3s = model->surfmesh.data_element3s;
9925         rsurface.modelelement3i_bufferobject = model->surfmesh.ebo3i;
9926         rsurface.modelelement3s_bufferobject = model->surfmesh.ebo3s;
9927         rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
9928         rsurface.modelnum_vertices = model->surfmesh.num_vertices;
9929         rsurface.modelnum_triangles = model->surfmesh.num_triangles;
9930         rsurface.modelsurfaces = model->data_surfaces;
9931         rsurface.vertex3f  = rsurface.modelvertex3f;
9932         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
9933         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
9934         rsurface.svector3f = rsurface.modelsvector3f;
9935         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
9936         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
9937         rsurface.tvector3f = rsurface.modeltvector3f;
9938         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
9939         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
9940         rsurface.normal3f  = rsurface.modelnormal3f;
9941         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
9942         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
9943         rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
9944 }
9945
9946 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)
9947 {
9948         rsurface.entity = r_refdef.scene.worldentity;
9949         rsurface.skeleton = NULL;
9950         rsurface.ent_skinnum = 0;
9951         rsurface.ent_qwskin = -1;
9952         rsurface.ent_shadertime = shadertime;
9953         rsurface.ent_flags = entflags;
9954         rsurface.modelnum_vertices = numvertices;
9955         rsurface.modelnum_triangles = numtriangles;
9956         if (rsurface.array_size < rsurface.modelnum_vertices)
9957                 R_Mesh_ResizeArrays(rsurface.modelnum_vertices);
9958         rsurface.matrix = *matrix;
9959         rsurface.inversematrix = *inversematrix;
9960         rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
9961         rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
9962         R_EntityMatrix(&rsurface.matrix);
9963         Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
9964         Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
9965         rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
9966         rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
9967         rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
9968         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
9969         VectorSet(rsurface.modellight_ambient, 0, 0, 0);
9970         VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
9971         VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
9972         VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
9973         VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
9974         Vector4Set(rsurface.colormod, r * r_refdef.view.colorscale, g * r_refdef.view.colorscale, b * r_refdef.view.colorscale, a);
9975         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);
9976         memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
9977         rsurface.frameblend[0].lerp = 1;
9978         rsurface.ent_alttextures = false;
9979         rsurface.basepolygonfactor = r_refdef.polygonfactor;
9980         rsurface.basepolygonoffset = r_refdef.polygonoffset;
9981         if (wanttangents)
9982         {
9983                 rsurface.modelvertex3f = vertex3f;
9984                 rsurface.modelsvector3f = svector3f ? svector3f : rsurface.array_modelsvector3f;
9985                 rsurface.modeltvector3f = tvector3f ? tvector3f : rsurface.array_modeltvector3f;
9986                 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
9987         }
9988         else if (wantnormals)
9989         {
9990                 rsurface.modelvertex3f = vertex3f;
9991                 rsurface.modelsvector3f = NULL;
9992                 rsurface.modeltvector3f = NULL;
9993                 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
9994         }
9995         else
9996         {
9997                 rsurface.modelvertex3f = vertex3f;
9998                 rsurface.modelsvector3f = NULL;
9999                 rsurface.modeltvector3f = NULL;
10000                 rsurface.modelnormal3f = NULL;
10001         }
10002         rsurface.modelvertex3f_bufferobject = 0;
10003         rsurface.modelvertex3f_bufferoffset = 0;
10004         rsurface.modelsvector3f_bufferobject = 0;
10005         rsurface.modelsvector3f_bufferoffset = 0;
10006         rsurface.modeltvector3f_bufferobject = 0;
10007         rsurface.modeltvector3f_bufferoffset = 0;
10008         rsurface.modelnormal3f_bufferobject = 0;
10009         rsurface.modelnormal3f_bufferoffset = 0;
10010         rsurface.generatedvertex = true;
10011         rsurface.modellightmapcolor4f  = color4f;
10012         rsurface.modellightmapcolor4f_bufferobject = 0;
10013         rsurface.modellightmapcolor4f_bufferoffset = 0;
10014         rsurface.modeltexcoordtexture2f  = texcoord2f;
10015         rsurface.modeltexcoordtexture2f_bufferobject = 0;
10016         rsurface.modeltexcoordtexture2f_bufferoffset = 0;
10017         rsurface.modeltexcoordlightmap2f  = NULL;
10018         rsurface.modeltexcoordlightmap2f_bufferobject = 0;
10019         rsurface.modeltexcoordlightmap2f_bufferoffset = 0;
10020         rsurface.modelelement3i = element3i;
10021         rsurface.modelelement3s = element3s;
10022         rsurface.modelelement3i_bufferobject = 0;
10023         rsurface.modelelement3s_bufferobject = 0;
10024         rsurface.modellightmapoffsets = NULL;
10025         rsurface.modelsurfaces = NULL;
10026         rsurface.vertex3f  = rsurface.modelvertex3f;
10027         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
10028         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
10029         rsurface.svector3f = rsurface.modelsvector3f;
10030         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
10031         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
10032         rsurface.tvector3f = rsurface.modeltvector3f;
10033         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
10034         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
10035         rsurface.normal3f  = rsurface.modelnormal3f;
10036         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
10037         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
10038         rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
10039
10040         if (rsurface.modelnum_vertices && rsurface.modelelement3i)
10041         {
10042                 if ((wantnormals || wanttangents) && !normal3f)
10043                         Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
10044                 if (wanttangents && !svector3f)
10045                         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);
10046         }
10047 }
10048
10049 float RSurf_FogPoint(const float *v)
10050 {
10051         // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
10052         float FogPlaneViewDist = r_refdef.fogplaneviewdist;
10053         float FogPlaneVertexDist = DotProduct(r_refdef.fogplane, v) + r_refdef.fogplane[3];
10054         float FogHeightFade = r_refdef.fogheightfade;
10055         float fogfrac;
10056         unsigned int fogmasktableindex;
10057         if (r_refdef.fogplaneviewabove)
10058                 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
10059         else
10060                 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
10061         fogmasktableindex = (unsigned int)(VectorDistance(r_refdef.view.origin, v) * fogfrac * r_refdef.fogmasktabledistmultiplier);
10062         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
10063 }
10064
10065 float RSurf_FogVertex(const float *v)
10066 {
10067         // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
10068         float FogPlaneViewDist = rsurface.fogplaneviewdist;
10069         float FogPlaneVertexDist = DotProduct(rsurface.fogplane, v) + rsurface.fogplane[3];
10070         float FogHeightFade = rsurface.fogheightfade;
10071         float fogfrac;
10072         unsigned int fogmasktableindex;
10073         if (r_refdef.fogplaneviewabove)
10074                 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
10075         else
10076                 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
10077         fogmasktableindex = (unsigned int)(VectorDistance(rsurface.localvieworigin, v) * fogfrac * rsurface.fogmasktabledistmultiplier);
10078         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
10079 }
10080
10081 static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
10082 void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, const msurface_t **texturesurfacelist)
10083 {
10084         int deformindex;
10085         int texturesurfaceindex;
10086         int i, j;
10087         float amplitude;
10088         float animpos;
10089         float scale;
10090         const float *v1, *in_tc;
10091         float *out_tc;
10092         float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
10093         float waveparms[4];
10094         q3shaderinfo_deform_t *deform;
10095         // 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
10096         if (rsurface.generatedvertex)
10097         {
10098                 if (rsurface.texture->tcgen.tcgen == Q3TCGEN_ENVIRONMENT)
10099                         generatenormals = true;
10100                 for (i = 0;i < Q3MAXDEFORMS;i++)
10101                 {
10102                         if (rsurface.texture->deforms[i].deform == Q3DEFORM_AUTOSPRITE)
10103                         {
10104                                 generatetangents = true;
10105                                 generatenormals = true;
10106                         }
10107                         if (rsurface.texture->deforms[i].deform != Q3DEFORM_NONE)
10108                                 generatenormals = true;
10109                 }
10110                 if (generatenormals && !rsurface.modelnormal3f)
10111                 {
10112                         rsurface.normal3f = rsurface.modelnormal3f = rsurface.array_modelnormal3f;
10113                         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject = 0;
10114                         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset = 0;
10115                         Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
10116                 }
10117                 if (generatetangents && !rsurface.modelsvector3f)
10118                 {
10119                         rsurface.svector3f = rsurface.modelsvector3f = rsurface.array_modelsvector3f;
10120                         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject = 0;
10121                         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset = 0;
10122                         rsurface.tvector3f = rsurface.modeltvector3f = rsurface.array_modeltvector3f;
10123                         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject = 0;
10124                         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset = 0;
10125                         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);
10126                 }
10127         }
10128         rsurface.vertex3f  = rsurface.modelvertex3f;
10129         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
10130         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
10131         rsurface.svector3f = rsurface.modelsvector3f;
10132         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
10133         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
10134         rsurface.tvector3f = rsurface.modeltvector3f;
10135         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
10136         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
10137         rsurface.normal3f  = rsurface.modelnormal3f;
10138         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
10139         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
10140         // if vertices are deformed (sprite flares and things in maps, possibly
10141         // water waves, bulges and other deformations), generate them into
10142         // rsurface.deform* arrays from whatever the rsurface.* arrays point to
10143         // (may be static model data or generated data for an animated model, or
10144         //  the previous deform pass)
10145         for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
10146         {
10147                 switch (deform->deform)
10148                 {
10149                 default:
10150                 case Q3DEFORM_PROJECTIONSHADOW:
10151                 case Q3DEFORM_TEXT0:
10152                 case Q3DEFORM_TEXT1:
10153                 case Q3DEFORM_TEXT2:
10154                 case Q3DEFORM_TEXT3:
10155                 case Q3DEFORM_TEXT4:
10156                 case Q3DEFORM_TEXT5:
10157                 case Q3DEFORM_TEXT6:
10158                 case Q3DEFORM_TEXT7:
10159                 case Q3DEFORM_NONE:
10160                         break;
10161                 case Q3DEFORM_AUTOSPRITE:
10162                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
10163                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
10164                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
10165                         VectorNormalize(newforward);
10166                         VectorNormalize(newright);
10167                         VectorNormalize(newup);
10168                         // make deformed versions of only the model vertices used by the specified surfaces
10169                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10170                         {
10171                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10172                                 // a single autosprite surface can contain multiple sprites...
10173                                 for (j = 0;j < surface->num_vertices - 3;j += 4)
10174                                 {
10175                                         VectorClear(center);
10176                                         for (i = 0;i < 4;i++)
10177                                                 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
10178                                         VectorScale(center, 0.25f, center);
10179                                         VectorCopy((rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, forward);
10180                                         VectorCopy((rsurface.svector3f + 3 * surface->num_firstvertex) + j*3, right);
10181                                         VectorCopy((rsurface.tvector3f + 3 * surface->num_firstvertex) + j*3, up);
10182                                         for (i = 0;i < 4;i++)
10183                                         {
10184                                                 VectorSubtract((rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, center, v);
10185                                                 VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
10186                                         }
10187                                 }
10188                                 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);
10189                                 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);
10190                         }
10191                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
10192                         rsurface.vertex3f_bufferobject = 0;
10193                         rsurface.vertex3f_bufferoffset = 0;
10194                         rsurface.svector3f = rsurface.array_deformedsvector3f;
10195                         rsurface.svector3f_bufferobject = 0;
10196                         rsurface.svector3f_bufferoffset = 0;
10197                         rsurface.tvector3f = rsurface.array_deformedtvector3f;
10198                         rsurface.tvector3f_bufferobject = 0;
10199                         rsurface.tvector3f_bufferoffset = 0;
10200                         rsurface.normal3f = rsurface.array_deformednormal3f;
10201                         rsurface.normal3f_bufferobject = 0;
10202                         rsurface.normal3f_bufferoffset = 0;
10203                         break;
10204                 case Q3DEFORM_AUTOSPRITE2:
10205                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
10206                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
10207                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
10208                         VectorNormalize(newforward);
10209                         VectorNormalize(newright);
10210                         VectorNormalize(newup);
10211                         // make deformed versions of only the model vertices used by the specified surfaces
10212                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10213                         {
10214                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10215                                 const float *v1, *v2;
10216                                 vec3_t start, end;
10217                                 float f, l;
10218                                 struct
10219                                 {
10220                                         float length2;
10221                                         const float *v1;
10222                                         const float *v2;
10223                                 }
10224                                 shortest[2];
10225                                 memset(shortest, 0, sizeof(shortest));
10226                                 // a single autosprite surface can contain multiple sprites...
10227                                 for (j = 0;j < surface->num_vertices - 3;j += 4)
10228                                 {
10229                                         VectorClear(center);
10230                                         for (i = 0;i < 4;i++)
10231                                                 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
10232                                         VectorScale(center, 0.25f, center);
10233                                         // find the two shortest edges, then use them to define the
10234                                         // axis vectors for rotating around the central axis
10235                                         for (i = 0;i < 6;i++)
10236                                         {
10237                                                 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][0]);
10238                                                 v2 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][1]);
10239 #if 0
10240                                                 Debug_PolygonBegin(NULL, 0);
10241                                                 Debug_PolygonVertex(v1[0], v1[1], v1[2], 0, 0, 1, 0, 0, 1);
10242                                                 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);
10243                                                 Debug_PolygonVertex(v2[0], v2[1], v2[2], 0, 0, 1, 0, 0, 1);
10244                                                 Debug_PolygonEnd();
10245 #endif
10246                                                 l = VectorDistance2(v1, v2);
10247                                                 // this length bias tries to make sense of square polygons, assuming they are meant to be upright
10248                                                 if (v1[2] != v2[2])
10249                                                         l += (1.0f / 1024.0f);
10250                                                 if (shortest[0].length2 > l || i == 0)
10251                                                 {
10252                                                         shortest[1] = shortest[0];
10253                                                         shortest[0].length2 = l;
10254                                                         shortest[0].v1 = v1;
10255                                                         shortest[0].v2 = v2;
10256                                                 }
10257                                                 else if (shortest[1].length2 > l || i == 1)
10258                                                 {
10259                                                         shortest[1].length2 = l;
10260                                                         shortest[1].v1 = v1;
10261                                                         shortest[1].v2 = v2;
10262                                                 }
10263                                         }
10264                                         VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
10265                                         VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
10266 #if 0
10267                                         Debug_PolygonBegin(NULL, 0);
10268                                         Debug_PolygonVertex(start[0], start[1], start[2], 0, 0, 1, 1, 0, 1);
10269                                         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);
10270                                         Debug_PolygonVertex(end[0], end[1], end[2], 0, 0, 0, 1, 1, 1);
10271                                         Debug_PolygonEnd();
10272 #endif
10273                                         // this calculates the right vector from the shortest edge
10274                                         // and the up vector from the edge midpoints
10275                                         VectorSubtract(shortest[0].v1, shortest[0].v2, right);
10276                                         VectorNormalize(right);
10277                                         VectorSubtract(end, start, up);
10278                                         VectorNormalize(up);
10279                                         // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
10280                                         VectorSubtract(rsurface.localvieworigin, center, forward);
10281                                         //Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, forward);
10282                                         VectorNegate(forward, forward);
10283                                         VectorReflect(forward, 0, up, forward);
10284                                         VectorNormalize(forward);
10285                                         CrossProduct(up, forward, newright);
10286                                         VectorNormalize(newright);
10287 #if 0
10288                                         Debug_PolygonBegin(NULL, 0);
10289                                         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);
10290                                         Debug_PolygonVertex(center[0] + right[0] * 8, center[1] + right[1] * 8, center[2] + right[2] * 8, 0, 0, 0, 1, 0, 1);
10291                                         Debug_PolygonVertex(center[0] + up   [0] * 8, center[1] + up   [1] * 8, center[2] + up   [2] * 8, 0, 0, 0, 0, 1, 1);
10292                                         Debug_PolygonEnd();
10293 #endif
10294 #if 0
10295                                         Debug_PolygonBegin(NULL, 0);
10296                                         Debug_PolygonVertex(center[0] + forward [0] * 8, center[1] + forward [1] * 8, center[2] + forward [2] * 8, 0, 0, 1, 0, 0, 1);
10297                                         Debug_PolygonVertex(center[0] + newright[0] * 8, center[1] + newright[1] * 8, center[2] + newright[2] * 8, 0, 0, 0, 1, 0, 1);
10298                                         Debug_PolygonVertex(center[0] + up      [0] * 8, center[1] + up      [1] * 8, center[2] + up      [2] * 8, 0, 0, 0, 0, 1, 1);
10299                                         Debug_PolygonEnd();
10300 #endif
10301                                         // rotate the quad around the up axis vector, this is made
10302                                         // especially easy by the fact we know the quad is flat,
10303                                         // so we only have to subtract the center position and
10304                                         // measure distance along the right vector, and then
10305                                         // multiply that by the newright vector and add back the
10306                                         // center position
10307                                         // we also need to subtract the old position to undo the
10308                                         // displacement from the center, which we do with a
10309                                         // DotProduct, the subtraction/addition of center is also
10310                                         // optimized into DotProducts here
10311                                         l = DotProduct(right, center);
10312                                         for (i = 0;i < 4;i++)
10313                                         {
10314                                                 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + j + i);
10315                                                 f = DotProduct(right, v1) - l;
10316                                                 VectorMAMAM(1, v1, -f, right, f, newright, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
10317                                         }
10318                                 }
10319                                 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);
10320                                 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);
10321                         }
10322                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
10323                         rsurface.vertex3f_bufferobject = 0;
10324                         rsurface.vertex3f_bufferoffset = 0;
10325                         rsurface.svector3f = rsurface.array_deformedsvector3f;
10326                         rsurface.svector3f_bufferobject = 0;
10327                         rsurface.svector3f_bufferoffset = 0;
10328                         rsurface.tvector3f = rsurface.array_deformedtvector3f;
10329                         rsurface.tvector3f_bufferobject = 0;
10330                         rsurface.tvector3f_bufferoffset = 0;
10331                         rsurface.normal3f = rsurface.array_deformednormal3f;
10332                         rsurface.normal3f_bufferobject = 0;
10333                         rsurface.normal3f_bufferoffset = 0;
10334                         break;
10335                 case Q3DEFORM_NORMAL:
10336                         // deform the normals to make reflections wavey
10337                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10338                         {
10339                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10340                                 for (j = 0;j < surface->num_vertices;j++)
10341                                 {
10342                                         float vertex[3];
10343                                         float *normal = (rsurface.array_deformednormal3f  + 3 * surface->num_firstvertex) + j*3;
10344                                         VectorScale((rsurface.vertex3f  + 3 * surface->num_firstvertex) + j*3, 0.98f, vertex);
10345                                         VectorCopy((rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, normal);
10346                                         normal[0] += deform->parms[0] * noise4f(      vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
10347                                         normal[1] += deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
10348                                         normal[2] += deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
10349                                         VectorNormalize(normal);
10350                                 }
10351                                 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);
10352                         }
10353                         rsurface.svector3f = rsurface.array_deformedsvector3f;
10354                         rsurface.svector3f_bufferobject = 0;
10355                         rsurface.svector3f_bufferoffset = 0;
10356                         rsurface.tvector3f = rsurface.array_deformedtvector3f;
10357                         rsurface.tvector3f_bufferobject = 0;
10358                         rsurface.tvector3f_bufferoffset = 0;
10359                         rsurface.normal3f = rsurface.array_deformednormal3f;
10360                         rsurface.normal3f_bufferobject = 0;
10361                         rsurface.normal3f_bufferoffset = 0;
10362                         break;
10363                 case Q3DEFORM_WAVE:
10364                         // deform vertex array to make wavey water and flags and such
10365                         waveparms[0] = deform->waveparms[0];
10366                         waveparms[1] = deform->waveparms[1];
10367                         waveparms[2] = deform->waveparms[2];
10368                         waveparms[3] = deform->waveparms[3];
10369                         if(!R_TestQ3WaveFunc(deform->wavefunc, waveparms))
10370                                 break; // if wavefunc is a nop, don't make a dynamic vertex array
10371                         // this is how a divisor of vertex influence on deformation
10372                         animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
10373                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
10374                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10375                         {
10376                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10377                                 for (j = 0;j < surface->num_vertices;j++)
10378                                 {
10379                                         float *vertex = (rsurface.array_deformedvertex3f  + 3 * surface->num_firstvertex) + j*3;
10380                                         VectorCopy((rsurface.vertex3f  + 3 * surface->num_firstvertex) + j*3, vertex);
10381                                         // if the wavefunc depends on time, evaluate it per-vertex
10382                                         if (waveparms[3])
10383                                         {
10384                                                 waveparms[2] = deform->waveparms[2] + (vertex[0] + vertex[1] + vertex[2]) * animpos;
10385                                                 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
10386                                         }
10387                                         VectorMA(vertex, scale, (rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, vertex);
10388                                 }
10389                         }
10390                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
10391                         rsurface.vertex3f_bufferobject = 0;
10392                         rsurface.vertex3f_bufferoffset = 0;
10393                         break;
10394                 case Q3DEFORM_BULGE:
10395                         // deform vertex array to make the surface have moving bulges
10396                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10397                         {
10398                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10399                                 for (j = 0;j < surface->num_vertices;j++)
10400                                 {
10401                                         scale = sin((rsurface.modeltexcoordtexture2f[2 * (surface->num_firstvertex + j)] * deform->parms[0] + r_refdef.scene.time * deform->parms[2])) * deform->parms[1];
10402                                         VectorMA(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), scale, rsurface.normal3f + 3 * (surface->num_firstvertex + j), rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
10403                                 }
10404                         }
10405                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
10406                         rsurface.vertex3f_bufferobject = 0;
10407                         rsurface.vertex3f_bufferoffset = 0;
10408                         break;
10409                 case Q3DEFORM_MOVE:
10410                         // deform vertex array
10411                         if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
10412                                 break; // if wavefunc is a nop, don't make a dynamic vertex array
10413                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
10414                         VectorScale(deform->parms, scale, waveparms);
10415                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10416                         {
10417                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10418                                 for (j = 0;j < surface->num_vertices;j++)
10419                                         VectorAdd(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), waveparms, rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
10420                         }
10421                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
10422                         rsurface.vertex3f_bufferobject = 0;
10423                         rsurface.vertex3f_bufferoffset = 0;
10424                         break;
10425                 }
10426         }
10427         // generate texcoords based on the chosen texcoord source
10428         switch(rsurface.texture->tcgen.tcgen)
10429         {
10430         default:
10431         case Q3TCGEN_TEXTURE:
10432                 rsurface.texcoordtexture2f               = rsurface.modeltexcoordtexture2f;
10433                 rsurface.texcoordtexture2f_bufferobject  = rsurface.modeltexcoordtexture2f_bufferobject;
10434                 rsurface.texcoordtexture2f_bufferoffset  = rsurface.modeltexcoordtexture2f_bufferoffset;
10435                 break;
10436         case Q3TCGEN_LIGHTMAP:
10437                 rsurface.texcoordtexture2f               = rsurface.modeltexcoordlightmap2f;
10438                 rsurface.texcoordtexture2f_bufferobject  = rsurface.modeltexcoordlightmap2f_bufferobject;
10439                 rsurface.texcoordtexture2f_bufferoffset  = rsurface.modeltexcoordlightmap2f_bufferoffset;
10440                 break;
10441         case Q3TCGEN_VECTOR:
10442                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10443                 {
10444                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10445                         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)
10446                         {
10447                                 out_tc[0] = DotProduct(v1, rsurface.texture->tcgen.parms);
10448                                 out_tc[1] = DotProduct(v1, rsurface.texture->tcgen.parms + 3);
10449                         }
10450                 }
10451                 rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
10452                 rsurface.texcoordtexture2f_bufferobject  = 0;
10453                 rsurface.texcoordtexture2f_bufferoffset  = 0;
10454                 break;
10455         case Q3TCGEN_ENVIRONMENT:
10456                 // make environment reflections using a spheremap
10457                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10458                 {
10459                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10460                         const float *vertex = rsurface.modelvertex3f + 3 * surface->num_firstvertex;
10461                         const float *normal = rsurface.modelnormal3f + 3 * surface->num_firstvertex;
10462                         float *out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;
10463                         for (j = 0;j < surface->num_vertices;j++, vertex += 3, normal += 3, out_tc += 2)
10464                         {
10465                                 // identical to Q3A's method, but executed in worldspace so
10466                                 // carried models can be shiny too
10467
10468                                 float viewer[3], d, reflected[3], worldreflected[3];
10469
10470                                 VectorSubtract(rsurface.localvieworigin, vertex, viewer);
10471                                 // VectorNormalize(viewer);
10472
10473                                 d = DotProduct(normal, viewer);
10474
10475                                 reflected[0] = normal[0]*2*d - viewer[0];
10476                                 reflected[1] = normal[1]*2*d - viewer[1];
10477                                 reflected[2] = normal[2]*2*d - viewer[2];
10478                                 // note: this is proportinal to viewer, so we can normalize later
10479
10480                                 Matrix4x4_Transform3x3(&rsurface.matrix, reflected, worldreflected);
10481                                 VectorNormalize(worldreflected);
10482
10483                                 // note: this sphere map only uses world x and z!
10484                                 // so positive and negative y will LOOK THE SAME.
10485                                 out_tc[0] = 0.5 + 0.5 * worldreflected[1];
10486                                 out_tc[1] = 0.5 - 0.5 * worldreflected[2];
10487                         }
10488                 }
10489                 rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
10490                 rsurface.texcoordtexture2f_bufferobject  = 0;
10491                 rsurface.texcoordtexture2f_bufferoffset  = 0;
10492                 break;
10493         }
10494         // the only tcmod that needs software vertex processing is turbulent, so
10495         // check for it here and apply the changes if needed
10496         // and we only support that as the first one
10497         // (handling a mixture of turbulent and other tcmods would be problematic
10498         //  without punting it entirely to a software path)
10499         if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
10500         {
10501                 amplitude = rsurface.texture->tcmods[0].parms[1];
10502                 animpos = rsurface.texture->tcmods[0].parms[2] + r_refdef.scene.time * rsurface.texture->tcmods[0].parms[3];
10503                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10504                 {
10505                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10506                         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)
10507                         {
10508                                 out_tc[0] = in_tc[0] + amplitude * sin(((v1[0] + v1[2]) * 1.0 / 1024.0f + animpos) * M_PI * 2);
10509                                 out_tc[1] = in_tc[1] + amplitude * sin(((v1[1]        ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
10510                         }
10511                 }
10512                 rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
10513                 rsurface.texcoordtexture2f_bufferobject  = 0;
10514                 rsurface.texcoordtexture2f_bufferoffset  = 0;
10515         }
10516         rsurface.texcoordlightmap2f              = rsurface.modeltexcoordlightmap2f;
10517         rsurface.texcoordlightmap2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
10518         rsurface.texcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
10519         R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
10520 }
10521
10522 void RSurf_DrawBatch_Simple(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10523 {
10524         int i, j;
10525         const msurface_t *surface = texturesurfacelist[0];
10526         const msurface_t *surface2;
10527         int firstvertex;
10528         int endvertex;
10529         int numvertices;
10530         int numtriangles;
10531         // TODO: lock all array ranges before render, rather than on each surface
10532         if (texturenumsurfaces == 1)
10533                 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);
10534         else if (r_batchmode.integer == 2)
10535         {
10536                 #define MAXBATCHTRIANGLES 65536
10537                 int batchtriangles = 0;
10538                 static int batchelements[MAXBATCHTRIANGLES*3];
10539                 for (i = 0;i < texturenumsurfaces;i = j)
10540                 {
10541                         surface = texturesurfacelist[i];
10542                         j = i + 1;
10543                         if (surface->num_triangles > MAXBATCHTRIANGLES)
10544                         {
10545                                 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);
10546                                 continue;
10547                         }
10548                         memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
10549                         batchtriangles = surface->num_triangles;
10550                         firstvertex = surface->num_firstvertex;
10551                         endvertex = surface->num_firstvertex + surface->num_vertices;
10552                         for (;j < texturenumsurfaces;j++)
10553                         {
10554                                 surface2 = texturesurfacelist[j];
10555                                 if (batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
10556                                         break;
10557                                 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
10558                                 batchtriangles += surface2->num_triangles;
10559                                 firstvertex = min(firstvertex, surface2->num_firstvertex);
10560                                 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
10561                         }
10562                         surface2 = texturesurfacelist[j-1];
10563                         numvertices = endvertex - firstvertex;
10564                         R_Mesh_Draw(firstvertex, numvertices, 0, batchtriangles, batchelements, NULL, 0, 0);
10565                 }
10566         }
10567         else if (r_batchmode.integer == 1)
10568         {
10569                 for (i = 0;i < texturenumsurfaces;i = j)
10570                 {
10571                         surface = texturesurfacelist[i];
10572                         for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
10573                                 if (texturesurfacelist[j] != surface2)
10574                                         break;
10575                         surface2 = texturesurfacelist[j-1];
10576                         numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
10577                         numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
10578                         R_Mesh_Draw(surface->num_firstvertex, numvertices, surface->num_firsttriangle, numtriangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
10579                 }
10580         }
10581         else
10582         {
10583                 for (i = 0;i < texturenumsurfaces;i++)
10584                 {
10585                         surface = texturesurfacelist[i];
10586                         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);
10587                 }
10588         }
10589 }
10590
10591 static void RSurf_BindLightmapForSurface(const msurface_t *surface)
10592 {
10593         switch(vid.renderpath)
10594         {
10595         case RENDERPATH_CGGL:
10596 #ifdef SUPPORTCG
10597                 if (r_cg_permutation->fp_Texture_Lightmap ) CG_BindTexture(r_cg_permutation->fp_Texture_Lightmap , surface->lightmaptexture );CHECKCGERROR
10598                 if (r_cg_permutation->fp_Texture_Deluxemap) CG_BindTexture(r_cg_permutation->fp_Texture_Deluxemap, surface->deluxemaptexture);CHECKCGERROR
10599 #endif
10600                 break;
10601         case RENDERPATH_GL20:
10602                 if (r_glsl_permutation->loc_Texture_Lightmap  >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP , surface->lightmaptexture );
10603                 if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(GL20TU_DELUXEMAP, surface->deluxemaptexture);
10604                 break;
10605         case RENDERPATH_GL13:
10606         case RENDERPATH_GL11:
10607                 R_Mesh_TexBind(0, surface->lightmaptexture);
10608                 break;
10609         }
10610 }
10611
10612 static void RSurf_BindReflectionForSurface(const msurface_t *surface)
10613 {
10614         // pick the closest matching water plane and bind textures
10615         int planeindex, vertexindex;
10616         float d, bestd;
10617         vec3_t vert;
10618         const float *v;
10619         r_waterstate_waterplane_t *p, *bestp;
10620         bestd = 0;
10621         bestp = NULL;
10622         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
10623         {
10624                 if(p->camera_entity != rsurface.texture->camera_entity)
10625                         continue;
10626                 d = 0;
10627                 for (vertexindex = 0, v = rsurface.modelvertex3f + surface->num_firstvertex * 3;vertexindex < surface->num_vertices;vertexindex++, v += 3)
10628                 {
10629                         Matrix4x4_Transform(&rsurface.matrix, v, vert);
10630                         d += fabs(PlaneDiff(vert, &p->plane));
10631                 }
10632                 if (bestd > d || !bestp)
10633                 {
10634                         bestd = d;
10635                         bestp = p;
10636                 }
10637         }
10638         switch(vid.renderpath)
10639         {
10640         case RENDERPATH_CGGL:
10641 #ifdef SUPPORTCG
10642                 if (r_cg_permutation->fp_Texture_Refraction) {CG_BindTexture(r_cg_permutation->fp_Texture_Refraction, bestp ? bestp->texture_refraction : r_texture_black);CHECKCGERROR}
10643                 else if (r_cg_permutation->fp_Texture_First) {CG_BindTexture(r_cg_permutation->fp_Texture_First, bestp ? bestp->texture_camera : r_texture_black);CHECKCGERROR}
10644                 if (r_cg_permutation->fp_Texture_Reflection) {CG_BindTexture(r_cg_permutation->fp_Texture_Reflection, bestp ? bestp->texture_reflection : r_texture_black);CHECKCGERROR}
10645 #endif
10646                 break;
10647         case RENDERPATH_GL20:
10648                 if (r_glsl_permutation->loc_Texture_Refraction >= 0) R_Mesh_TexBind(GL20TU_REFRACTION, bestp ? bestp->texture_refraction : r_texture_black);
10649                 else if (r_glsl_permutation->loc_Texture_First >= 0) R_Mesh_TexBind(GL20TU_FIRST, bestp ? bestp->texture_camera : r_texture_black);
10650                 if (r_glsl_permutation->loc_Texture_Reflection >= 0) R_Mesh_TexBind(GL20TU_REFLECTION, bestp ? bestp->texture_reflection : r_texture_black);
10651                 break;
10652         case RENDERPATH_GL13:
10653         case RENDERPATH_GL11:
10654                 break;
10655         }
10656 }
10657
10658 static void RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10659 {
10660         int i;
10661         const msurface_t *surface;
10662         if (r_waterstate.renderingscene)
10663                 return;
10664         for (i = 0;i < texturenumsurfaces;i++)
10665         {
10666                 surface = texturesurfacelist[i];
10667                 RSurf_BindLightmapForSurface(surface);
10668                 RSurf_BindReflectionForSurface(surface);
10669                 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);
10670         }
10671 }
10672
10673 static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10674 {
10675         int i;
10676         int j;
10677         const msurface_t *surface = texturesurfacelist[0];
10678         const msurface_t *surface2;
10679         int firstvertex;
10680         int endvertex;
10681         int numvertices;
10682         int numtriangles;
10683         if (texturenumsurfaces == 1)
10684         {
10685                 RSurf_BindLightmapForSurface(surface);
10686                 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);
10687         }
10688         else if (r_batchmode.integer == 2)
10689         {
10690                 int batchtriangles = 0;
10691                 static int batchelements[MAXBATCHTRIANGLES*3];
10692                 for (i = 0;i < texturenumsurfaces;i = j)
10693                 {
10694                         surface = texturesurfacelist[i];
10695                         RSurf_BindLightmapForSurface(surface);
10696                         j = i + 1;
10697                         if (surface->num_triangles > MAXBATCHTRIANGLES)
10698                         {
10699                                 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);
10700                                 continue;
10701                         }
10702                         memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
10703                         batchtriangles = surface->num_triangles;
10704                         firstvertex = surface->num_firstvertex;
10705                         endvertex = surface->num_firstvertex + surface->num_vertices;
10706                         for (;j < texturenumsurfaces;j++)
10707                         {
10708                                 surface2 = texturesurfacelist[j];
10709                                 if (surface2->lightmaptexture != surface->lightmaptexture || batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
10710                                         break;
10711                                 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
10712                                 batchtriangles += surface2->num_triangles;
10713                                 firstvertex = min(firstvertex, surface2->num_firstvertex);
10714                                 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
10715                         }
10716                         surface2 = texturesurfacelist[j-1];
10717                         numvertices = endvertex - firstvertex;
10718                         R_Mesh_Draw(firstvertex, numvertices, 0, batchtriangles, batchelements, NULL, 0, 0);
10719                 }
10720         }
10721         else if (r_batchmode.integer == 1)
10722         {
10723 #if 0
10724                 Con_Printf("%s batch sizes ignoring lightmap:", rsurface.texture->name);
10725                 for (i = 0;i < texturenumsurfaces;i = j)
10726                 {
10727                         surface = texturesurfacelist[i];
10728                         for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
10729                                 if (texturesurfacelist[j] != surface2)
10730                                         break;
10731                         Con_Printf(" %i", j - i);
10732                 }
10733                 Con_Printf("\n");
10734                 Con_Printf("%s batch sizes honoring lightmap:", rsurface.texture->name);
10735 #endif
10736                 for (i = 0;i < texturenumsurfaces;i = j)
10737                 {
10738                         surface = texturesurfacelist[i];
10739                         RSurf_BindLightmapForSurface(surface);
10740                         for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
10741                                 if (texturesurfacelist[j] != surface2 || texturesurfacelist[j]->lightmaptexture != surface->lightmaptexture)
10742                                         break;
10743 #if 0
10744                         Con_Printf(" %i", j - i);
10745 #endif
10746                         surface2 = texturesurfacelist[j-1];
10747                         numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
10748                         numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
10749                         R_Mesh_Draw(surface->num_firstvertex, numvertices, surface->num_firsttriangle, numtriangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
10750                 }
10751 #if 0
10752                 Con_Printf("\n");
10753 #endif
10754         }
10755         else
10756         {
10757                 for (i = 0;i < texturenumsurfaces;i++)
10758                 {
10759                         surface = texturesurfacelist[i];
10760                         RSurf_BindLightmapForSurface(surface);
10761                         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);
10762                 }
10763         }
10764 }
10765
10766 static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10767 {
10768         int j;
10769         int texturesurfaceindex;
10770         if (r_showsurfaces.integer == 2)
10771         {
10772                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10773                 {
10774                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10775                         for (j = 0;j < surface->num_triangles;j++)
10776                         {
10777                                 float f = ((j + surface->num_firsttriangle) & 31) * (1.0f / 31.0f) * r_refdef.view.colorscale;
10778                                 GL_Color(f, f, f, 1);
10779                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle + j, 1, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
10780                         }
10781                 }
10782         }
10783         else
10784         {
10785                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10786                 {
10787                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10788                         int k = (int)(((size_t)surface) / sizeof(msurface_t));
10789                         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);
10790                         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);
10791                 }
10792         }
10793 }
10794
10795 static void RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10796 {
10797         int texturesurfaceindex;
10798         int i;
10799         const float *v;
10800         float *c2;
10801         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10802         {
10803                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10804                 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)
10805                 {
10806                         c2[0] = 0.5;
10807                         c2[1] = 0.5;
10808                         c2[2] = 0.5;
10809                         c2[3] = 1;
10810                 }
10811         }
10812         rsurface.lightmapcolor4f = rsurface.array_color4f;
10813         rsurface.lightmapcolor4f_bufferobject = 0;
10814         rsurface.lightmapcolor4f_bufferoffset = 0;
10815 }
10816
10817 static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10818 {
10819         int texturesurfaceindex;
10820         int i;
10821         float f;
10822         const float *v;
10823         const float *c;
10824         float *c2;
10825         if (rsurface.lightmapcolor4f)
10826         {
10827                 // generate color arrays for the surfaces in this list
10828                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10829                 {
10830                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10831                         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)
10832                         {
10833                                 f = RSurf_FogVertex(v);
10834                                 c2[0] = c[0] * f;
10835                                 c2[1] = c[1] * f;
10836                                 c2[2] = c[2] * f;
10837                                 c2[3] = c[3];
10838                         }
10839                 }
10840         }
10841         else
10842         {
10843                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10844                 {
10845                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10846                         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)
10847                         {
10848                                 f = RSurf_FogVertex(v);
10849                                 c2[0] = f;
10850                                 c2[1] = f;
10851                                 c2[2] = f;
10852                                 c2[3] = 1;
10853                         }
10854                 }
10855         }
10856         rsurface.lightmapcolor4f = rsurface.array_color4f;
10857         rsurface.lightmapcolor4f_bufferobject = 0;
10858         rsurface.lightmapcolor4f_bufferoffset = 0;
10859 }
10860
10861 static void RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10862 {
10863         int texturesurfaceindex;
10864         int i;
10865         float f;
10866         const float *v;
10867         const float *c;
10868         float *c2;
10869         if (!rsurface.lightmapcolor4f)
10870                 return;
10871         // generate color arrays for the surfaces in this list
10872         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10873         {
10874                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10875                 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)
10876                 {
10877                         f = RSurf_FogVertex(v);
10878                         c2[0] = c[0] * f + r_refdef.fogcolor[0] * (1 - f);
10879                         c2[1] = c[1] * f + r_refdef.fogcolor[1] * (1 - f);
10880                         c2[2] = c[2] * f + r_refdef.fogcolor[2] * (1 - f);
10881                         c2[3] = c[3];
10882                 }
10883         }
10884         rsurface.lightmapcolor4f = rsurface.array_color4f;
10885         rsurface.lightmapcolor4f_bufferobject = 0;
10886         rsurface.lightmapcolor4f_bufferoffset = 0;
10887 }
10888
10889 static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a)
10890 {
10891         int texturesurfaceindex;
10892         int i;
10893         const float *c;
10894         float *c2;
10895         if (!rsurface.lightmapcolor4f)
10896                 return;
10897         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10898         {
10899                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10900                 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)
10901                 {
10902                         c2[0] = c[0] * r;
10903                         c2[1] = c[1] * g;
10904                         c2[2] = c[2] * b;
10905                         c2[3] = c[3] * a;
10906                 }
10907         }
10908         rsurface.lightmapcolor4f = rsurface.array_color4f;
10909         rsurface.lightmapcolor4f_bufferobject = 0;
10910         rsurface.lightmapcolor4f_bufferoffset = 0;
10911 }
10912
10913 static void RSurf_DrawBatch_GL11_ApplyAmbient(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10914 {
10915         int texturesurfaceindex;
10916         int i;
10917         const float *c;
10918         float *c2;
10919         if (!rsurface.lightmapcolor4f)
10920                 return;
10921         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10922         {
10923                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10924                 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)
10925                 {
10926                         c2[0] = c[0] + r_refdef.scene.ambient;
10927                         c2[1] = c[1] + r_refdef.scene.ambient;
10928                         c2[2] = c[2] + r_refdef.scene.ambient;
10929                         c2[3] = c[3];
10930                 }
10931         }
10932         rsurface.lightmapcolor4f = rsurface.array_color4f;
10933         rsurface.lightmapcolor4f_bufferobject = 0;
10934         rsurface.lightmapcolor4f_bufferoffset = 0;
10935 }
10936
10937 static void RSurf_DrawBatch_GL11_Lightmap(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
10938 {
10939         // TODO: optimize
10940         rsurface.lightmapcolor4f = NULL;
10941         rsurface.lightmapcolor4f_bufferobject = 0;
10942         rsurface.lightmapcolor4f_bufferoffset = 0;
10943         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
10944         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
10945         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
10946         GL_Color(r, g, b, a);
10947         RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist);
10948 }
10949
10950 static void RSurf_DrawBatch_GL11_Unlit(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
10951 {
10952         // TODO: optimize applyfog && applycolor case
10953         // just apply fog if necessary, and tint the fog color array if necessary
10954         rsurface.lightmapcolor4f = NULL;
10955         rsurface.lightmapcolor4f_bufferobject = 0;
10956         rsurface.lightmapcolor4f_bufferoffset = 0;
10957         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
10958         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
10959         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
10960         GL_Color(r, g, b, a);
10961         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
10962 }
10963
10964 static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
10965 {
10966         int texturesurfaceindex;
10967         int i;
10968         float *c;
10969         // TODO: optimize
10970         if (texturesurfacelist[0]->lightmapinfo)
10971         {
10972                 // generate color arrays for the surfaces in this list
10973                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10974                 {
10975                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10976                         for (i = 0, c = rsurface.array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
10977                         {
10978                                 if (surface->lightmapinfo->samples)
10979                                 {
10980                                         const unsigned char *lm = surface->lightmapinfo->samples + (rsurface.modellightmapoffsets + surface->num_firstvertex)[i];
10981                                         float scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
10982                                         VectorScale(lm, scale, c);
10983                                         if (surface->lightmapinfo->styles[1] != 255)
10984                                         {
10985                                                 int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
10986                                                 lm += size3;
10987                                                 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
10988                                                 VectorMA(c, scale, lm, c);
10989                                                 if (surface->lightmapinfo->styles[2] != 255)
10990                                                 {
10991                                                         lm += size3;
10992                                                         scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
10993                                                         VectorMA(c, scale, lm, c);
10994                                                         if (surface->lightmapinfo->styles[3] != 255)
10995                                                         {
10996                                                                 lm += size3;
10997                                                                 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
10998                                                                 VectorMA(c, scale, lm, c);
10999                                                         }
11000                                                 }
11001                                         }
11002                                 }
11003                                 else
11004                                         VectorClear(c);
11005                                 c[3] = 1;
11006                         }
11007                 }
11008                 rsurface.lightmapcolor4f = rsurface.array_color4f;
11009                 rsurface.lightmapcolor4f_bufferobject = 0;
11010                 rsurface.lightmapcolor4f_bufferoffset = 0;
11011         }
11012         else
11013         {
11014                 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
11015                 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
11016                 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
11017         }
11018         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
11019         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
11020         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
11021         GL_Color(r, g, b, a);
11022         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11023 }
11024
11025 static void RSurf_DrawBatch_GL11_ApplyVertexShade(int texturenumsurfaces, const msurface_t **texturesurfacelist, float *r, float *g, float *b, float *a, qboolean *applycolor)
11026 {
11027         int texturesurfaceindex;
11028         int i;
11029         float f;
11030         float alpha;
11031         const float *v;
11032         const float *n;
11033         float *c;
11034         vec3_t ambientcolor;
11035         vec3_t diffusecolor;
11036         vec3_t lightdir;
11037         // TODO: optimize
11038         // model lighting
11039         VectorCopy(rsurface.modellight_lightdir, lightdir);
11040         f = 0.5f * r_refdef.lightmapintensity;
11041         ambientcolor[0] = rsurface.modellight_ambient[0] * *r * f;
11042         ambientcolor[1] = rsurface.modellight_ambient[1] * *g * f;
11043         ambientcolor[2] = rsurface.modellight_ambient[2] * *b * f;
11044         diffusecolor[0] = rsurface.modellight_diffuse[0] * *r * f;
11045         diffusecolor[1] = rsurface.modellight_diffuse[1] * *g * f;
11046         diffusecolor[2] = rsurface.modellight_diffuse[2] * *b * f;
11047         alpha = *a;
11048         if (VectorLength2(diffusecolor) > 0 && rsurface.normal3f)
11049         {
11050                 // generate color arrays for the surfaces in this list
11051                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
11052                 {
11053                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
11054                         int numverts = surface->num_vertices;
11055                         v = rsurface.vertex3f + 3 * surface->num_firstvertex;
11056                         n = rsurface.normal3f + 3 * surface->num_firstvertex;
11057                         c = rsurface.array_color4f + 4 * surface->num_firstvertex;
11058                         // q3-style directional shading
11059                         for (i = 0;i < numverts;i++, v += 3, n += 3, c += 4)
11060                         {
11061                                 if ((f = DotProduct(n, lightdir)) > 0)
11062                                         VectorMA(ambientcolor, f, diffusecolor, c);
11063                                 else
11064                                         VectorCopy(ambientcolor, c);
11065                                 c[3] = alpha;
11066                         }
11067                 }
11068                 *r = 1;
11069                 *g = 1;
11070                 *b = 1;
11071                 *a = 1;
11072                 rsurface.lightmapcolor4f = rsurface.array_color4f;
11073                 rsurface.lightmapcolor4f_bufferobject = 0;
11074                 rsurface.lightmapcolor4f_bufferoffset = 0;
11075                 *applycolor = false;
11076         }
11077         else
11078         {
11079                 *r = ambientcolor[0];
11080                 *g = ambientcolor[1];
11081                 *b = ambientcolor[2];
11082                 rsurface.lightmapcolor4f = NULL;
11083                 rsurface.lightmapcolor4f_bufferobject = 0;
11084                 rsurface.lightmapcolor4f_bufferoffset = 0;
11085         }
11086 }
11087
11088 static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
11089 {
11090         RSurf_DrawBatch_GL11_ApplyVertexShade(texturenumsurfaces, texturesurfacelist, &r, &g, &b, &a, &applycolor);
11091         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
11092         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
11093         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
11094         GL_Color(r, g, b, a);
11095         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11096 }
11097
11098 void RSurf_SetupDepthAndCulling(void)
11099 {
11100         // submodels are biased to avoid z-fighting with world surfaces that they
11101         // may be exactly overlapping (avoids z-fighting artifacts on certain
11102         // doors and things in Quake maps)
11103         GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
11104         GL_PolygonOffset(rsurface.basepolygonfactor + rsurface.texture->biaspolygonfactor, rsurface.basepolygonoffset + rsurface.texture->biaspolygonoffset);
11105         GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
11106         GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_refdef.view.cullface_back);
11107 }
11108
11109 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, const msurface_t **texturesurfacelist)
11110 {
11111         // transparent sky would be ridiculous
11112         if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
11113                 return;
11114         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
11115         skyrenderlater = true;
11116         RSurf_SetupDepthAndCulling();
11117         GL_DepthMask(true);
11118         // LordHavoc: HalfLife maps have freaky skypolys so don't use
11119         // skymasking on them, and Quake3 never did sky masking (unlike
11120         // software Quake and software Quake2), so disable the sky masking
11121         // in Quake3 maps as it causes problems with q3map2 sky tricks,
11122         // and skymasking also looks very bad when noclipping outside the
11123         // level, so don't use it then either.
11124         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_refdef.viewcache.world_novis)
11125         {
11126                 GL_Color(r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], 1);
11127                 R_Mesh_ColorPointer(NULL, 0, 0);
11128                 R_Mesh_ResetTextureState();
11129                 if (skyrendermasked)
11130                 {
11131                         R_SetupShader_DepthOrShadow();
11132                         // depth-only (masking)
11133                         GL_ColorMask(0,0,0,0);
11134                         // just to make sure that braindead drivers don't draw
11135                         // anything despite that colormask...
11136                         GL_BlendFunc(GL_ZERO, GL_ONE);
11137                 }
11138                 else
11139                 {
11140                         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
11141                         // fog sky
11142                         GL_BlendFunc(GL_ONE, GL_ZERO);
11143                 }
11144                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11145                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11146                 if (skyrendermasked)
11147                         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
11148         }
11149         R_Mesh_ResetTextureState();
11150         GL_Color(1, 1, 1, 1);
11151 }
11152
11153 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
11154 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
11155 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
11156 {
11157         if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA)))
11158                 return;
11159         RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
11160         if (prepass)
11161         {
11162                 // render screenspace normalmap to texture
11163                 GL_DepthMask(true);
11164                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_DEFERREDGEOMETRY);
11165                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11166         }
11167         else if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_CAMERA)) && !r_waterstate.renderingscene)
11168         {
11169                 // render water or distortion background, then blend surface on top
11170                 GL_DepthMask(true);
11171                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND);
11172                 RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist);
11173                 GL_DepthMask(false);
11174                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE);
11175                 if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
11176                         RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist);
11177                 else
11178                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11179         }
11180         else
11181         {
11182                 // render surface normally
11183                 GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
11184                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE);
11185                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
11186                         RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist);
11187                 else if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
11188                         RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist);
11189                 else
11190                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11191         }
11192 }
11193
11194 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
11195 {
11196         // OpenGL 1.3 path - anything not completely ancient
11197         int texturesurfaceindex;
11198         qboolean applycolor;
11199         qboolean applyfog;
11200         int layerindex;
11201         const texturelayer_t *layer;
11202         RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
11203
11204         for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
11205         {
11206                 vec4_t layercolor;
11207                 int layertexrgbscale;
11208                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
11209                 {
11210                         if (layerindex == 0)
11211                                 GL_AlphaTest(true);
11212                         else
11213                         {
11214                                 GL_AlphaTest(false);
11215                                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
11216                         }
11217                 }
11218                 GL_DepthMask(layer->depthmask && writedepth);
11219                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
11220                 if (layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2)
11221                 {
11222                         layertexrgbscale = 4;
11223                         VectorScale(layer->color, 0.25f, layercolor);
11224                 }
11225                 else if (layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1)
11226                 {
11227                         layertexrgbscale = 2;
11228                         VectorScale(layer->color, 0.5f, layercolor);
11229                 }
11230                 else
11231                 {
11232                         layertexrgbscale = 1;
11233                         VectorScale(layer->color, 1.0f, layercolor);
11234                 }
11235                 layercolor[3] = layer->color[3];
11236                 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
11237                 R_Mesh_ColorPointer(NULL, 0, 0);
11238                 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
11239                 switch (layer->type)
11240                 {
11241                 case TEXTURELAYERTYPE_LITTEXTURE:
11242                         // single-pass lightmapped texture with 2x rgbscale
11243                         R_Mesh_TexBind(0, r_texture_white);
11244                         R_Mesh_TexMatrix(0, NULL);
11245                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
11246                         R_Mesh_TexCoordPointer(0, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
11247                         R_Mesh_TexBind(1, layer->texture);
11248                         R_Mesh_TexMatrix(1, &layer->texmatrix);
11249                         R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
11250                         R_Mesh_TexCoordPointer(1, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
11251                         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
11252                                 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
11253                         else if (rsurface.uselightmaptexture)
11254                                 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
11255                         else
11256                                 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
11257                         break;
11258                 case TEXTURELAYERTYPE_TEXTURE:
11259                         // singletexture unlit texture with transparency support
11260                         R_Mesh_TexBind(0, layer->texture);
11261                         R_Mesh_TexMatrix(0, &layer->texmatrix);
11262                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
11263                         R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
11264                         R_Mesh_TexBind(1, 0);
11265                         R_Mesh_TexCoordPointer(1, 2, NULL, 0, 0);
11266                         RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
11267                         break;
11268                 case TEXTURELAYERTYPE_FOG:
11269                         // singletexture fogging
11270                         if (layer->texture)
11271                         {
11272                                 R_Mesh_TexBind(0, layer->texture);
11273                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
11274                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
11275                                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
11276                         }
11277                         else
11278                         {
11279                                 R_Mesh_TexBind(0, 0);
11280                                 R_Mesh_TexCoordPointer(0, 2, NULL, 0, 0);
11281                         }
11282                         R_Mesh_TexBind(1, 0);
11283                         R_Mesh_TexCoordPointer(1, 2, NULL, 0, 0);
11284                         // generate a color array for the fog pass
11285                         R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
11286                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
11287                         {
11288                                 int i;
11289                                 float f;
11290                                 const float *v;
11291                                 float *c;
11292                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
11293                                 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)
11294                                 {
11295                                         f = 1 - RSurf_FogVertex(v);
11296                                         c[0] = layercolor[0];
11297                                         c[1] = layercolor[1];
11298                                         c[2] = layercolor[2];
11299                                         c[3] = f * layercolor[3];
11300                                 }
11301                         }
11302                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11303                         break;
11304                 default:
11305                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
11306                 }
11307         }
11308         CHECKGLERROR
11309         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
11310         {
11311                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
11312                 GL_AlphaTest(false);
11313         }
11314 }
11315
11316 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
11317 {
11318         // OpenGL 1.1 - crusty old voodoo path
11319         int texturesurfaceindex;
11320         qboolean applyfog;
11321         int layerindex;
11322         const texturelayer_t *layer;
11323         RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
11324
11325         for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
11326         {
11327                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
11328                 {
11329                         if (layerindex == 0)
11330                                 GL_AlphaTest(true);
11331                         else
11332                         {
11333                                 GL_AlphaTest(false);
11334                                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
11335                         }
11336                 }
11337                 GL_DepthMask(layer->depthmask && writedepth);
11338                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
11339                 R_Mesh_ColorPointer(NULL, 0, 0);
11340                 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
11341                 switch (layer->type)
11342                 {
11343                 case TEXTURELAYERTYPE_LITTEXTURE:
11344                         if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
11345                         {
11346                                 // two-pass lit texture with 2x rgbscale
11347                                 // first the lightmap pass
11348                                 R_Mesh_TexBind(0, r_texture_white);
11349                                 R_Mesh_TexMatrix(0, NULL);
11350                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
11351                                 R_Mesh_TexCoordPointer(0, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
11352                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
11353                                         RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
11354                                 else if (rsurface.uselightmaptexture)
11355                                         RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
11356                                 else
11357                                         RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
11358                                 // then apply the texture to it
11359                                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
11360                                 R_Mesh_TexBind(0, layer->texture);
11361                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
11362                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
11363                                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
11364                                 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);
11365                         }
11366                         else
11367                         {
11368                                 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
11369                                 R_Mesh_TexBind(0, layer->texture);
11370                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
11371                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
11372                                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
11373                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
11374                                         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);
11375                                 else
11376                                         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);
11377                         }
11378                         break;
11379                 case TEXTURELAYERTYPE_TEXTURE:
11380                         // singletexture unlit texture with transparency support
11381                         R_Mesh_TexBind(0, layer->texture);
11382                         R_Mesh_TexMatrix(0, &layer->texmatrix);
11383                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
11384                         R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
11385                         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);
11386                         break;
11387                 case TEXTURELAYERTYPE_FOG:
11388                         // singletexture fogging
11389                         if (layer->texture)
11390                         {
11391                                 R_Mesh_TexBind(0, layer->texture);
11392                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
11393                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
11394                                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
11395                         }
11396                         else
11397                         {
11398                                 R_Mesh_TexBind(0, 0);
11399                                 R_Mesh_TexCoordPointer(0, 2, NULL, 0, 0);
11400                         }
11401                         // generate a color array for the fog pass
11402                         R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
11403                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
11404                         {
11405                                 int i;
11406                                 float f;
11407                                 const float *v;
11408                                 float *c;
11409                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
11410                                 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)
11411                                 {
11412                                         f = 1 - RSurf_FogVertex(v);
11413                                         c[0] = layer->color[0];
11414                                         c[1] = layer->color[1];
11415                                         c[2] = layer->color[2];
11416                                         c[3] = f * layer->color[3];
11417                                 }
11418                         }
11419                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11420                         break;
11421                 default:
11422                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
11423                 }
11424         }
11425         CHECKGLERROR
11426         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
11427         {
11428                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
11429                 GL_AlphaTest(false);
11430         }
11431 }
11432
11433 static void R_DrawTextureSurfaceList_ShowSurfaces3(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
11434 {
11435         float c[4];
11436
11437         GL_AlphaTest(false);
11438         R_Mesh_ColorPointer(NULL, 0, 0);
11439         R_Mesh_ResetTextureState();
11440         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
11441
11442         if(rsurface.texture && rsurface.texture->currentskinframe)
11443         {
11444                 memcpy(c, rsurface.texture->currentskinframe->avgcolor, sizeof(c));
11445                 c[3] *= rsurface.texture->currentalpha;
11446         }
11447         else
11448         {
11449                 c[0] = 1;
11450                 c[1] = 0;
11451                 c[2] = 1;
11452                 c[3] = 1;
11453         }
11454
11455         if (rsurface.texture->pantstexture || rsurface.texture->shirttexture)
11456         {
11457                 c[0] = 0.5 * (rsurface.colormap_pantscolor[0] * 0.3 + rsurface.colormap_shirtcolor[0] * 0.7);
11458                 c[1] = 0.5 * (rsurface.colormap_pantscolor[1] * 0.3 + rsurface.colormap_shirtcolor[1] * 0.7);
11459                 c[2] = 0.5 * (rsurface.colormap_pantscolor[2] * 0.3 + rsurface.colormap_shirtcolor[2] * 0.7);
11460         }
11461
11462         // brighten it up (as texture value 127 means "unlit")
11463         c[0] *= 2 * r_refdef.view.colorscale;
11464         c[1] *= 2 * r_refdef.view.colorscale;
11465         c[2] *= 2 * r_refdef.view.colorscale;
11466
11467         if(rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERALPHA)
11468                 c[3] *= r_wateralpha.value;
11469
11470         if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHA && c[3] != 1)
11471         {
11472                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
11473                 GL_DepthMask(false);
11474         }
11475         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
11476         {
11477                 GL_BlendFunc(GL_ONE, GL_ONE);
11478                 GL_DepthMask(false);
11479         }
11480         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
11481         {
11482                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // can't do alpha test without texture, so let's blend instead
11483                 GL_DepthMask(false);
11484         }
11485         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
11486         {
11487                 GL_BlendFunc(rsurface.texture->customblendfunc[0], rsurface.texture->customblendfunc[1]);
11488                 GL_DepthMask(false);
11489         }
11490         else
11491         {
11492                 GL_BlendFunc(GL_ONE, GL_ZERO);
11493                 GL_DepthMask(writedepth);
11494         }
11495
11496         rsurface.lightmapcolor4f = NULL;
11497
11498         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
11499         {
11500                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11501
11502                 rsurface.lightmapcolor4f = NULL;
11503                 rsurface.lightmapcolor4f_bufferobject = 0;
11504                 rsurface.lightmapcolor4f_bufferoffset = 0;
11505         }
11506         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
11507         {
11508                 qboolean applycolor = true;
11509                 float one = 1.0;
11510
11511                 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
11512
11513                 r_refdef.lightmapintensity = 1;
11514                 RSurf_DrawBatch_GL11_ApplyVertexShade(texturenumsurfaces, texturesurfacelist, &one, &one, &one, &one, &applycolor);
11515                 r_refdef.lightmapintensity = 0; // we're in showsurfaces, after all
11516         }
11517         else
11518         {
11519                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11520
11521                 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
11522                 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
11523                 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
11524         }
11525
11526         if(!rsurface.lightmapcolor4f)
11527                 RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(texturenumsurfaces, texturesurfacelist);
11528
11529         RSurf_DrawBatch_GL11_ApplyAmbient(texturenumsurfaces, texturesurfacelist);
11530         RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, c[0], c[1], c[2], c[3]);
11531         if(r_refdef.fogenabled)
11532                 RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(texturenumsurfaces, texturesurfacelist);
11533
11534         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
11535         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11536 }
11537
11538 static void R_DrawWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
11539 {
11540         CHECKGLERROR
11541         RSurf_SetupDepthAndCulling();
11542         if (r_showsurfaces.integer == 3 && !prepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY))
11543         {
11544                 R_DrawTextureSurfaceList_ShowSurfaces3(texturenumsurfaces, texturesurfacelist, writedepth);
11545                 return;
11546         }
11547         switch (vid.renderpath)
11548         {
11549         case RENDERPATH_GL20:
11550         case RENDERPATH_CGGL:
11551                 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
11552                 break;
11553         case RENDERPATH_GL13:
11554                 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
11555                 break;
11556         case RENDERPATH_GL11:
11557                 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
11558                 break;
11559         }
11560         CHECKGLERROR
11561 }
11562
11563 static void R_DrawModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
11564 {
11565         CHECKGLERROR
11566         RSurf_SetupDepthAndCulling();
11567         if (r_showsurfaces.integer == 3 && !prepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY))
11568         {
11569                 R_DrawTextureSurfaceList_ShowSurfaces3(texturenumsurfaces, texturesurfacelist, writedepth);
11570                 return;
11571         }
11572         switch (vid.renderpath)
11573         {
11574         case RENDERPATH_GL20:
11575         case RENDERPATH_CGGL:
11576                 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
11577                 break;
11578         case RENDERPATH_GL13:
11579                 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
11580                 break;
11581         case RENDERPATH_GL11:
11582                 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
11583                 break;
11584         }
11585         CHECKGLERROR
11586 }
11587
11588 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
11589 {
11590         int i, j;
11591         int texturenumsurfaces, endsurface;
11592         texture_t *texture;
11593         const msurface_t *surface;
11594 #define MAXBATCH_TRANSPARENTSURFACES 256
11595         const msurface_t *texturesurfacelist[MAXBATCH_TRANSPARENTSURFACES];
11596
11597         // if the model is static it doesn't matter what value we give for
11598         // wantnormals and wanttangents, so this logic uses only rules applicable
11599         // to a model, knowing that they are meaningless otherwise
11600         if (ent == r_refdef.scene.worldentity)
11601                 RSurf_ActiveWorldEntity();
11602         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
11603                 RSurf_ActiveModelEntity(ent, false, false, false);
11604         else
11605         {
11606                 switch (vid.renderpath)
11607                 {
11608                 case RENDERPATH_GL20:
11609                 case RENDERPATH_CGGL:
11610                         RSurf_ActiveModelEntity(ent, true, true, false);
11611                         break;
11612                 case RENDERPATH_GL13:
11613                 case RENDERPATH_GL11:
11614                         RSurf_ActiveModelEntity(ent, true, false, false);
11615                         break;
11616                 }
11617         }
11618
11619         if (r_transparentdepthmasking.integer)
11620         {
11621                 qboolean setup = false;
11622                 for (i = 0;i < numsurfaces;i = j)
11623                 {
11624                         j = i + 1;
11625                         surface = rsurface.modelsurfaces + surfacelist[i];
11626                         texture = surface->texture;
11627                         rsurface.texture = R_GetCurrentTexture(texture);
11628                         rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
11629                         // scan ahead until we find a different texture
11630                         endsurface = min(i + 1024, numsurfaces);
11631                         texturenumsurfaces = 0;
11632                         texturesurfacelist[texturenumsurfaces++] = surface;
11633                         for (;j < endsurface;j++)
11634                         {
11635                                 surface = rsurface.modelsurfaces + surfacelist[j];
11636                                 if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
11637                                         break;
11638                                 texturesurfacelist[texturenumsurfaces++] = surface;
11639                         }
11640                         if (!(rsurface.texture->currentmaterialflags & MATERIALFLAG_TRANSDEPTH))
11641                                 continue;
11642                         // render the range of surfaces as depth
11643                         if (!setup)
11644                         {
11645                                 setup = true;
11646                                 GL_ColorMask(0,0,0,0);
11647                                 GL_Color(1,1,1,1);
11648                                 GL_DepthTest(true);
11649                                 GL_BlendFunc(GL_ONE, GL_ZERO);
11650                                 GL_DepthMask(true);
11651                                 GL_AlphaTest(false);
11652                                 R_Mesh_ColorPointer(NULL, 0, 0);
11653                                 R_Mesh_ResetTextureState();
11654                                 R_SetupShader_DepthOrShadow();
11655                         }
11656                         RSurf_SetupDepthAndCulling();
11657                         RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11658                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11659                 }
11660                 if (setup)
11661                         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
11662         }
11663
11664         for (i = 0;i < numsurfaces;i = j)
11665         {
11666                 j = i + 1;
11667                 surface = rsurface.modelsurfaces + surfacelist[i];
11668                 texture = surface->texture;
11669                 rsurface.texture = R_GetCurrentTexture(texture);
11670                 rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
11671                 // scan ahead until we find a different texture
11672                 endsurface = min(i + MAXBATCH_TRANSPARENTSURFACES, numsurfaces);
11673                 texturenumsurfaces = 0;
11674                 texturesurfacelist[texturenumsurfaces++] = surface;
11675                 for (;j < endsurface;j++)
11676                 {
11677                         surface = rsurface.modelsurfaces + surfacelist[j];
11678                         if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
11679                                 break;
11680                         texturesurfacelist[texturenumsurfaces++] = surface;
11681                 }
11682                 // render the range of surfaces
11683                 if (ent == r_refdef.scene.worldentity)
11684                         R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
11685                 else
11686                         R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
11687         }
11688         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
11689         GL_AlphaTest(false);
11690 }
11691
11692 static void R_ProcessTransparentTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, const entity_render_t *queueentity)
11693 {
11694         // transparent surfaces get pushed off into the transparent queue
11695         int surfacelistindex;
11696         const msurface_t *surface;
11697         vec3_t tempcenter, center;
11698         for (surfacelistindex = 0;surfacelistindex < texturenumsurfaces;surfacelistindex++)
11699         {
11700                 surface = texturesurfacelist[surfacelistindex];
11701                 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
11702                 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
11703                 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
11704                 Matrix4x4_Transform(&rsurface.matrix, tempcenter, center);
11705                 if (queueentity->transparent_offset) // transparent offset
11706                 {
11707                         center[0] += r_refdef.view.forward[0]*queueentity->transparent_offset;
11708                         center[1] += r_refdef.view.forward[1]*queueentity->transparent_offset;
11709                         center[2] += r_refdef.view.forward[2]*queueentity->transparent_offset;
11710                 }
11711                 R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_refdef.view.origin : center, R_DrawSurface_TransparentCallback, queueentity, surface - rsurface.modelsurfaces, rsurface.rtlight);
11712         }
11713 }
11714
11715 static void R_ProcessWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, qboolean prepass)
11716 {
11717         const entity_render_t *queueentity = r_refdef.scene.worldentity;
11718         CHECKGLERROR
11719         if (depthonly)
11720         {
11721                 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
11722                         return;
11723                 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
11724                         return;
11725                 RSurf_SetupDepthAndCulling();
11726                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11727                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11728         }
11729         else if (prepass)
11730         {
11731                 if (!rsurface.texture->currentnumlayers)
11732                         return;
11733                 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
11734                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
11735                 else
11736                         R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
11737         }
11738         else if (r_showsurfaces.integer && !r_refdef.view.showdebug && !prepass)
11739         {
11740                 RSurf_SetupDepthAndCulling();
11741                 GL_AlphaTest(false);
11742                 R_Mesh_ColorPointer(NULL, 0, 0);
11743                 R_Mesh_ResetTextureState();
11744                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
11745                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11746                 GL_DepthMask(true);
11747                 GL_BlendFunc(GL_ONE, GL_ZERO);
11748                 GL_Color(0, 0, 0, 1);
11749                 GL_DepthTest(writedepth);
11750                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11751         }
11752         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3 && !prepass)
11753         {
11754                 RSurf_SetupDepthAndCulling();
11755                 GL_AlphaTest(false);
11756                 R_Mesh_ColorPointer(NULL, 0, 0);
11757                 R_Mesh_ResetTextureState();
11758                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
11759                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11760                 GL_DepthMask(true);
11761                 GL_BlendFunc(GL_ONE, GL_ZERO);
11762                 GL_DepthTest(true);
11763                 RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
11764         }
11765         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
11766                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
11767         else if (!rsurface.texture->currentnumlayers)
11768                 return;
11769         else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
11770         {
11771                 // in the deferred case, transparent surfaces were queued during prepass
11772                 if (!r_shadow_usingdeferredprepass)
11773                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
11774         }
11775         else
11776         {
11777                 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
11778                 R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
11779         }
11780         CHECKGLERROR
11781 }
11782
11783 void R_QueueWorldSurfaceList(int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
11784 {
11785         int i, j;
11786         texture_t *texture;
11787         // break the surface list down into batches by texture and use of lightmapping
11788         for (i = 0;i < numsurfaces;i = j)
11789         {
11790                 j = i + 1;
11791                 // texture is the base texture pointer, rsurface.texture is the
11792                 // current frame/skin the texture is directing us to use (for example
11793                 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
11794                 // use skin 1 instead)
11795                 texture = surfacelist[i]->texture;
11796                 rsurface.texture = R_GetCurrentTexture(texture);
11797                 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL && !depthonly && !prepass;
11798                 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
11799                 {
11800                         // if this texture is not the kind we want, skip ahead to the next one
11801                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
11802                                 ;
11803                         continue;
11804                 }
11805                 // simply scan ahead until we find a different texture or lightmap state
11806                 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
11807                         ;
11808                 // render the range of surfaces
11809                 R_ProcessWorldTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, prepass);
11810         }
11811 }
11812
11813 static void R_ProcessModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, const entity_render_t *queueentity, qboolean prepass)
11814 {
11815         CHECKGLERROR
11816         if (depthonly)
11817         {
11818                 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
11819                         return;
11820                 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
11821                         return;
11822                 RSurf_SetupDepthAndCulling();
11823                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11824                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11825         }
11826         else if (prepass)
11827         {
11828                 if (!rsurface.texture->currentnumlayers)
11829                         return;
11830                 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
11831                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
11832                 else
11833                         R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
11834         }
11835         else if (r_showsurfaces.integer && !r_refdef.view.showdebug)
11836         {
11837                 RSurf_SetupDepthAndCulling();
11838                 GL_AlphaTest(false);
11839                 R_Mesh_ColorPointer(NULL, 0, 0);
11840                 R_Mesh_ResetTextureState();
11841                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
11842                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11843                 GL_DepthMask(true);
11844                 GL_BlendFunc(GL_ONE, GL_ZERO);
11845                 GL_Color(0, 0, 0, 1);
11846                 GL_DepthTest(writedepth);
11847                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11848         }
11849         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
11850         {
11851                 RSurf_SetupDepthAndCulling();
11852                 GL_AlphaTest(false);
11853                 R_Mesh_ColorPointer(NULL, 0, 0);
11854                 R_Mesh_ResetTextureState();
11855                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
11856                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11857                 GL_DepthMask(true);
11858                 GL_BlendFunc(GL_ONE, GL_ZERO);
11859                 GL_DepthTest(true);
11860                 RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
11861         }
11862         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
11863                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
11864         else if (!rsurface.texture->currentnumlayers)
11865                 return;
11866         else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
11867         {
11868                 // in the deferred case, transparent surfaces were queued during prepass
11869                 if (!r_shadow_usingdeferredprepass)
11870                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
11871         }
11872         else
11873         {
11874                 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
11875                 R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
11876         }
11877         CHECKGLERROR
11878 }
11879
11880 void R_QueueModelSurfaceList(entity_render_t *ent, int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
11881 {
11882         int i, j;
11883         texture_t *texture;
11884         // break the surface list down into batches by texture and use of lightmapping
11885         for (i = 0;i < numsurfaces;i = j)
11886         {
11887                 j = i + 1;
11888                 // texture is the base texture pointer, rsurface.texture is the
11889                 // current frame/skin the texture is directing us to use (for example
11890                 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
11891                 // use skin 1 instead)
11892                 texture = surfacelist[i]->texture;
11893                 rsurface.texture = R_GetCurrentTexture(texture);
11894                 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL && !depthonly && !prepass;
11895                 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
11896                 {
11897                         // if this texture is not the kind we want, skip ahead to the next one
11898                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
11899                                 ;
11900                         continue;
11901                 }
11902                 // simply scan ahead until we find a different texture or lightmap state
11903                 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
11904                         ;
11905                 // render the range of surfaces
11906                 R_ProcessModelTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, ent, prepass);
11907         }
11908 }
11909
11910 float locboxvertex3f[6*4*3] =
11911 {
11912         1,0,1, 1,0,0, 1,1,0, 1,1,1,
11913         0,1,1, 0,1,0, 0,0,0, 0,0,1,
11914         1,1,1, 1,1,0, 0,1,0, 0,1,1,
11915         0,0,1, 0,0,0, 1,0,0, 1,0,1,
11916         0,0,1, 1,0,1, 1,1,1, 0,1,1,
11917         1,0,0, 0,0,0, 0,1,0, 1,1,0
11918 };
11919
11920 unsigned short locboxelements[6*2*3] =
11921 {
11922          0, 1, 2, 0, 2, 3,
11923          4, 5, 6, 4, 6, 7,
11924          8, 9,10, 8,10,11,
11925         12,13,14, 12,14,15,
11926         16,17,18, 16,18,19,
11927         20,21,22, 20,22,23
11928 };
11929
11930 void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
11931 {
11932         int i, j;
11933         cl_locnode_t *loc = (cl_locnode_t *)ent;
11934         vec3_t mins, size;
11935         float vertex3f[6*4*3];
11936         CHECKGLERROR
11937         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
11938         GL_DepthMask(false);
11939         GL_DepthRange(0, 1);
11940         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
11941         GL_DepthTest(true);
11942         GL_CullFace(GL_NONE);
11943         R_EntityMatrix(&identitymatrix);
11944
11945         R_Mesh_VertexPointer(vertex3f, 0, 0);
11946         R_Mesh_ColorPointer(NULL, 0, 0);
11947         R_Mesh_ResetTextureState();
11948         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
11949
11950         i = surfacelist[0];
11951         GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_refdef.view.colorscale,
11952                          ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_refdef.view.colorscale,
11953                          ((i & 0x01C0) >> 6) * (1.0f / 7.0f) * r_refdef.view.colorscale,
11954                         surfacelist[0] < 0 ? 0.5f : 0.125f);
11955
11956         if (VectorCompare(loc->mins, loc->maxs))
11957         {
11958                 VectorSet(size, 2, 2, 2);
11959                 VectorMA(loc->mins, -0.5f, size, mins);
11960         }
11961         else
11962         {
11963                 VectorCopy(loc->mins, mins);
11964                 VectorSubtract(loc->maxs, loc->mins, size);
11965         }
11966
11967         for (i = 0;i < 6*4*3;)
11968                 for (j = 0;j < 3;j++, i++)
11969                         vertex3f[i] = mins[j] + size[j] * locboxvertex3f[i];
11970
11971         R_Mesh_Draw(0, 6*4, 0, 6*2, NULL, locboxelements, 0, 0);
11972 }
11973
11974 void R_DrawLocs(void)
11975 {
11976         int index;
11977         cl_locnode_t *loc, *nearestloc;
11978         vec3_t center;
11979         nearestloc = CL_Locs_FindNearest(cl.movement_origin);
11980         for (loc = cl.locnodes, index = 0;loc;loc = loc->next, index++)
11981         {
11982                 VectorLerp(loc->mins, 0.5f, loc->maxs, center);
11983                 R_MeshQueue_AddTransparent(center, R_DrawLoc_Callback, (entity_render_t *)loc, loc == nearestloc ? -1 : index, NULL);
11984         }
11985 }
11986
11987 void R_DecalSystem_Reset(decalsystem_t *decalsystem)
11988 {
11989         if (decalsystem->decals)
11990                 Mem_Free(decalsystem->decals);
11991         memset(decalsystem, 0, sizeof(*decalsystem));
11992 }
11993
11994 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)
11995 {
11996         tridecal_t *decal;
11997         tridecal_t *decals;
11998         int i;
11999
12000         // expand or initialize the system
12001         if (decalsystem->maxdecals <= decalsystem->numdecals)
12002         {
12003                 decalsystem_t old = *decalsystem;
12004                 qboolean useshortelements;
12005                 decalsystem->maxdecals = max(16, decalsystem->maxdecals * 2);
12006                 useshortelements = decalsystem->maxdecals * 3 <= 65536;
12007                 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)));
12008                 decalsystem->color4f = (float *)(decalsystem->decals + decalsystem->maxdecals);
12009                 decalsystem->texcoord2f = (float *)(decalsystem->color4f + decalsystem->maxdecals*12);
12010                 decalsystem->vertex3f = (float *)(decalsystem->texcoord2f + decalsystem->maxdecals*6);
12011                 decalsystem->element3i = (int *)(decalsystem->vertex3f + decalsystem->maxdecals*9);
12012                 decalsystem->element3s = (useshortelements ? ((unsigned short *)(decalsystem->element3i + decalsystem->maxdecals*3)) : NULL);
12013                 if (decalsystem->numdecals)
12014                         memcpy(decalsystem->decals, old.decals, decalsystem->numdecals * sizeof(tridecal_t));
12015                 if (old.decals)
12016                         Mem_Free(old.decals);
12017                 for (i = 0;i < decalsystem->maxdecals*3;i++)
12018                         decalsystem->element3i[i] = i;
12019                 if (useshortelements)
12020                         for (i = 0;i < decalsystem->maxdecals*3;i++)
12021                                 decalsystem->element3s[i] = i;
12022         }
12023
12024         // grab a decal and search for another free slot for the next one
12025         decals = decalsystem->decals;
12026         decal = decalsystem->decals + (i = decalsystem->freedecal++);
12027         for (i = decalsystem->freedecal;i < decalsystem->numdecals && decals[i].color4ub[0][3];i++)
12028                 ;
12029         decalsystem->freedecal = i;
12030         if (decalsystem->numdecals <= i)
12031                 decalsystem->numdecals = i + 1;
12032
12033         // initialize the decal
12034         decal->lived = 0;
12035         decal->triangleindex = triangleindex;
12036         decal->surfaceindex = surfaceindex;
12037         decal->decalsequence = decalsequence;
12038         decal->color4ub[0][0] = (unsigned char)(c0[0]*255.0f);
12039         decal->color4ub[0][1] = (unsigned char)(c0[1]*255.0f);
12040         decal->color4ub[0][2] = (unsigned char)(c0[2]*255.0f);
12041         decal->color4ub[0][3] = 255;
12042         decal->color4ub[1][0] = (unsigned char)(c1[0]*255.0f);
12043         decal->color4ub[1][1] = (unsigned char)(c1[1]*255.0f);
12044         decal->color4ub[1][2] = (unsigned char)(c1[2]*255.0f);
12045         decal->color4ub[1][3] = 255;
12046         decal->color4ub[2][0] = (unsigned char)(c2[0]*255.0f);
12047         decal->color4ub[2][1] = (unsigned char)(c2[1]*255.0f);
12048         decal->color4ub[2][2] = (unsigned char)(c2[2]*255.0f);
12049         decal->color4ub[2][3] = 255;
12050         decal->vertex3f[0][0] = v0[0];
12051         decal->vertex3f[0][1] = v0[1];
12052         decal->vertex3f[0][2] = v0[2];
12053         decal->vertex3f[1][0] = v1[0];
12054         decal->vertex3f[1][1] = v1[1];
12055         decal->vertex3f[1][2] = v1[2];
12056         decal->vertex3f[2][0] = v2[0];
12057         decal->vertex3f[2][1] = v2[1];
12058         decal->vertex3f[2][2] = v2[2];
12059         decal->texcoord2f[0][0] = t0[0];
12060         decal->texcoord2f[0][1] = t0[1];
12061         decal->texcoord2f[1][0] = t1[0];
12062         decal->texcoord2f[1][1] = t1[1];
12063         decal->texcoord2f[2][0] = t2[0];
12064         decal->texcoord2f[2][1] = t2[1];
12065 }
12066
12067 extern cvar_t cl_decals_bias;
12068 extern cvar_t cl_decals_models;
12069 extern cvar_t cl_decals_newsystem_intensitymultiplier;
12070 // baseparms, parms, temps
12071 static void R_DecalSystem_SplatTriangle(decalsystem_t *decalsystem, float r, float g, float b, float a, float s1, float t1, float s2, float t2, int decalsequence, qboolean dynamic, float (*planes)[4], matrix4x4_t *projection, int triangleindex, int surfaceindex)
12072 {
12073         int cornerindex;
12074         int index;
12075         float v[9][3];
12076         const float *vertex3f;
12077         int numpoints;
12078         float points[2][9][3];
12079         float temp[3];
12080         float tc[9][2];
12081         float f;
12082         float c[9][4];
12083         const int *e;
12084
12085         e = rsurface.modelelement3i + 3*triangleindex;
12086
12087         vertex3f = rsurface.modelvertex3f;
12088
12089         for (cornerindex = 0;cornerindex < 3;cornerindex++)
12090         {
12091                 index = 3*e[cornerindex];
12092                 VectorCopy(vertex3f + index, v[cornerindex]);
12093         }
12094         // cull backfaces
12095         //TriangleNormal(v[0], v[1], v[2], normal);
12096         //if (DotProduct(normal, localnormal) < 0.0f)
12097         //      continue;
12098         // clip by each of the box planes formed from the projection matrix
12099         // if anything survives, we emit the decal
12100         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]);
12101         if (numpoints < 3)
12102                 return;
12103         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]);
12104         if (numpoints < 3)
12105                 return;
12106         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]);
12107         if (numpoints < 3)
12108                 return;
12109         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]);
12110         if (numpoints < 3)
12111                 return;
12112         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]);
12113         if (numpoints < 3)
12114                 return;
12115         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]);
12116         if (numpoints < 3)
12117                 return;
12118         // some part of the triangle survived, so we have to accept it...
12119         if (dynamic)
12120         {
12121                 // dynamic always uses the original triangle
12122                 numpoints = 3;
12123                 for (cornerindex = 0;cornerindex < 3;cornerindex++)
12124                 {
12125                         index = 3*e[cornerindex];
12126                         VectorCopy(vertex3f + index, v[cornerindex]);
12127                 }
12128         }
12129         for (cornerindex = 0;cornerindex < numpoints;cornerindex++)
12130         {
12131                 // convert vertex positions to texcoords
12132                 Matrix4x4_Transform(projection, v[cornerindex], temp);
12133                 tc[cornerindex][0] = (temp[1]+1.0f)*0.5f * (s2-s1) + s1;
12134                 tc[cornerindex][1] = (temp[2]+1.0f)*0.5f * (t2-t1) + t1;
12135                 // calculate distance fade from the projection origin
12136                 f = a * (1.0f-fabs(temp[0])) * cl_decals_newsystem_intensitymultiplier.value;
12137                 f = bound(0.0f, f, 1.0f);
12138                 c[cornerindex][0] = r * f;
12139                 c[cornerindex][1] = g * f;
12140                 c[cornerindex][2] = b * f;
12141                 c[cornerindex][3] = 1.0f;
12142                 //VectorMA(v[cornerindex], cl_decals_bias.value, localnormal, v[cornerindex]);
12143         }
12144         if (dynamic)
12145                 R_DecalSystem_SpawnTriangle(decalsystem, v[0], v[1], v[2], tc[0], tc[1], tc[2], c[0], c[1], c[2], triangleindex, surfaceindex, decalsequence);
12146         else
12147                 for (cornerindex = 0;cornerindex < numpoints-2;cornerindex++)
12148                         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);
12149 }
12150 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)
12151 {
12152         matrix4x4_t projection;
12153         decalsystem_t *decalsystem;
12154         qboolean dynamic;
12155         dp_model_t *model;
12156         const msurface_t *surface;
12157         const msurface_t *surfaces;
12158         const int *surfacelist;
12159         const texture_t *texture;
12160         int numtriangles;
12161         int numsurfacelist;
12162         int surfacelistindex;
12163         int surfaceindex;
12164         int triangleindex;
12165         float localorigin[3];
12166         float localnormal[3];
12167         float localmins[3];
12168         float localmaxs[3];
12169         float localsize;
12170         //float normal[3];
12171         float planes[6][4];
12172         float angles[3];
12173         bih_t *bih;
12174         int bih_triangles_count;
12175         int bih_triangles[256];
12176         int bih_surfaces[256];
12177
12178         decalsystem = &ent->decalsystem;
12179         model = ent->model;
12180         if (!model || !ent->allowdecals || ent->alpha < 1 || (ent->flags & (RENDER_ADDITIVE | RENDER_NODEPTHTEST)))
12181         {
12182                 R_DecalSystem_Reset(&ent->decalsystem);
12183                 return;
12184         }
12185
12186         if (!model->brush.data_nodes && !cl_decals_models.integer)
12187         {
12188                 if (decalsystem->model)
12189                         R_DecalSystem_Reset(decalsystem);
12190                 return;
12191         }
12192
12193         if (decalsystem->model != model)
12194                 R_DecalSystem_Reset(decalsystem);
12195         decalsystem->model = model;
12196
12197         RSurf_ActiveModelEntity(ent, false, false, false);
12198
12199         Matrix4x4_Transform(&rsurface.inversematrix, worldorigin, localorigin);
12200         Matrix4x4_Transform3x3(&rsurface.inversematrix, worldnormal, localnormal);
12201         VectorNormalize(localnormal);
12202         localsize = worldsize*rsurface.inversematrixscale;
12203         localmins[0] = localorigin[0] - localsize;
12204         localmins[1] = localorigin[1] - localsize;
12205         localmins[2] = localorigin[2] - localsize;
12206         localmaxs[0] = localorigin[0] + localsize;
12207         localmaxs[1] = localorigin[1] + localsize;
12208         localmaxs[2] = localorigin[2] + localsize;
12209
12210         //VectorCopy(localnormal, planes[4]);
12211         //VectorVectors(planes[4], planes[2], planes[0]);
12212         AnglesFromVectors(angles, localnormal, NULL, false);
12213         AngleVectors(angles, planes[0], planes[2], planes[4]);
12214         VectorNegate(planes[0], planes[1]);
12215         VectorNegate(planes[2], planes[3]);
12216         VectorNegate(planes[4], planes[5]);
12217         planes[0][3] = DotProduct(planes[0], localorigin) - localsize;
12218         planes[1][3] = DotProduct(planes[1], localorigin) - localsize;
12219         planes[2][3] = DotProduct(planes[2], localorigin) - localsize;
12220         planes[3][3] = DotProduct(planes[3], localorigin) - localsize;
12221         planes[4][3] = DotProduct(planes[4], localorigin) - localsize;
12222         planes[5][3] = DotProduct(planes[5], localorigin) - localsize;
12223
12224 #if 1
12225 // works
12226 {
12227         matrix4x4_t forwardprojection;
12228         Matrix4x4_CreateFromQuakeEntity(&forwardprojection, localorigin[0], localorigin[1], localorigin[2], angles[0], angles[1], angles[2], localsize);
12229         Matrix4x4_Invert_Simple(&projection, &forwardprojection);
12230 }
12231 #else
12232 // broken
12233 {
12234         float projectionvector[4][3];
12235         VectorScale(planes[0], ilocalsize, projectionvector[0]);
12236         VectorScale(planes[2], ilocalsize, projectionvector[1]);
12237         VectorScale(planes[4], ilocalsize, projectionvector[2]);
12238         projectionvector[0][0] = planes[0][0] * ilocalsize;
12239         projectionvector[0][1] = planes[1][0] * ilocalsize;
12240         projectionvector[0][2] = planes[2][0] * ilocalsize;
12241         projectionvector[1][0] = planes[0][1] * ilocalsize;
12242         projectionvector[1][1] = planes[1][1] * ilocalsize;
12243         projectionvector[1][2] = planes[2][1] * ilocalsize;
12244         projectionvector[2][0] = planes[0][2] * ilocalsize;
12245         projectionvector[2][1] = planes[1][2] * ilocalsize;
12246         projectionvector[2][2] = planes[2][2] * ilocalsize;
12247         projectionvector[3][0] = -(localorigin[0]*projectionvector[0][0]+localorigin[1]*projectionvector[1][0]+localorigin[2]*projectionvector[2][0]);
12248         projectionvector[3][1] = -(localorigin[0]*projectionvector[0][1]+localorigin[1]*projectionvector[1][1]+localorigin[2]*projectionvector[2][1]);
12249         projectionvector[3][2] = -(localorigin[0]*projectionvector[0][2]+localorigin[1]*projectionvector[1][2]+localorigin[2]*projectionvector[2][2]);
12250         Matrix4x4_FromVectors(&projection, projectionvector[0], projectionvector[1], projectionvector[2], projectionvector[3]);
12251 }
12252 #endif
12253
12254         dynamic = model->surfmesh.isanimated;
12255         numsurfacelist = model->nummodelsurfaces;
12256         surfacelist = model->sortedmodelsurfaces;
12257         surfaces = model->data_surfaces;
12258
12259         bih = NULL;
12260         bih_triangles_count = -1;
12261         if(!dynamic)
12262         {
12263                 if(model->render_bih.numleafs)
12264                         bih = &model->render_bih;
12265                 else if(model->collision_bih.numleafs)
12266                         bih = &model->collision_bih;
12267         }
12268         if(bih)
12269                 bih_triangles_count = BIH_GetTriangleListForBox(bih, sizeof(bih_triangles) / sizeof(*bih_triangles), bih_triangles, bih_surfaces, localmins, localmaxs);
12270         if(bih_triangles_count == 0)
12271                 return;
12272         if(bih_triangles_count > (int) (sizeof(bih_triangles) / sizeof(*bih_triangles))) // hit too many, likely bad anyway
12273                 return;
12274         if(bih_triangles_count > 0)
12275         {
12276                 for (triangleindex = 0; triangleindex < bih_triangles_count; ++triangleindex)
12277                 {
12278                         surfaceindex = bih_surfaces[triangleindex];
12279                         surface = surfaces + surfaceindex;
12280                         texture = surface->texture;
12281                         if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
12282                                 continue;
12283                         if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS)
12284                                 continue;
12285                         R_DecalSystem_SplatTriangle(decalsystem, r, g, b, a, s1, t1, s2, t2, decalsequence, dynamic, planes, &projection, bih_triangles[triangleindex], surfaceindex);
12286                 }
12287         }
12288         else
12289         {
12290                 for (surfacelistindex = 0;surfacelistindex < numsurfacelist;surfacelistindex++)
12291                 {
12292                         surfaceindex = surfacelist[surfacelistindex];
12293                         surface = surfaces + surfaceindex;
12294                         // check cull box first because it rejects more than any other check
12295                         if (!dynamic && !BoxesOverlap(surface->mins, surface->maxs, localmins, localmaxs))
12296                                 continue;
12297                         // skip transparent surfaces
12298                         texture = surface->texture;
12299                         if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
12300                                 continue;
12301                         if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS)
12302                                 continue;
12303                         numtriangles = surface->num_triangles;
12304                         for (triangleindex = 0; triangleindex < numtriangles; triangleindex++)
12305                                 R_DecalSystem_SplatTriangle(decalsystem, r, g, b, a, s1, t1, s2, t2, decalsequence, dynamic, planes, &projection, triangleindex + surface->num_firsttriangle, surfaceindex);
12306                 }
12307         }
12308 }
12309
12310 // do not call this outside of rendering code - use R_DecalSystem_SplatEntities instead
12311 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)
12312 {
12313         int renderentityindex;
12314         float worldmins[3];
12315         float worldmaxs[3];
12316         entity_render_t *ent;
12317
12318         if (!cl_decals_newsystem.integer)
12319                 return;
12320
12321         worldmins[0] = worldorigin[0] - worldsize;
12322         worldmins[1] = worldorigin[1] - worldsize;
12323         worldmins[2] = worldorigin[2] - worldsize;
12324         worldmaxs[0] = worldorigin[0] + worldsize;
12325         worldmaxs[1] = worldorigin[1] + worldsize;
12326         worldmaxs[2] = worldorigin[2] + worldsize;
12327
12328         R_DecalSystem_SplatEntity(r_refdef.scene.worldentity, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
12329
12330         for (renderentityindex = 0;renderentityindex < r_refdef.scene.numentities;renderentityindex++)
12331         {
12332                 ent = r_refdef.scene.entities[renderentityindex];
12333                 if (!BoxesOverlap(ent->mins, ent->maxs, worldmins, worldmaxs))
12334                         continue;
12335
12336                 R_DecalSystem_SplatEntity(ent, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
12337         }
12338 }
12339
12340 typedef struct r_decalsystem_splatqueue_s
12341 {
12342         vec3_t worldorigin;
12343         vec3_t worldnormal;
12344         float color[4];
12345         float tcrange[4];
12346         float worldsize;
12347         int decalsequence;
12348 }
12349 r_decalsystem_splatqueue_t;
12350
12351 int r_decalsystem_numqueued = 0;
12352 r_decalsystem_splatqueue_t r_decalsystem_queue[MAX_DECALSYSTEM_QUEUE];
12353
12354 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)
12355 {
12356         r_decalsystem_splatqueue_t *queue;
12357
12358         if (!cl_decals_newsystem.integer || r_decalsystem_numqueued == MAX_DECALSYSTEM_QUEUE)
12359                 return;
12360
12361         queue = &r_decalsystem_queue[r_decalsystem_numqueued++];
12362         VectorCopy(worldorigin, queue->worldorigin);
12363         VectorCopy(worldnormal, queue->worldnormal);
12364         Vector4Set(queue->color, r, g, b, a);
12365         Vector4Set(queue->tcrange, s1, t1, s2, t2);
12366         queue->worldsize = worldsize;
12367         queue->decalsequence = cl.decalsequence++;
12368 }
12369
12370 static void R_DecalSystem_ApplySplatEntitiesQueue(void)
12371 {
12372         int i;
12373         r_decalsystem_splatqueue_t *queue;
12374
12375         for (i = 0, queue = r_decalsystem_queue;i < r_decalsystem_numqueued;i++, queue++)
12376                 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);
12377         r_decalsystem_numqueued = 0;
12378 }
12379
12380 extern cvar_t cl_decals_max;
12381 static void R_DrawModelDecals_FadeEntity(entity_render_t *ent)
12382 {
12383         int i;
12384         decalsystem_t *decalsystem = &ent->decalsystem;
12385         int numdecals;
12386         int killsequence;
12387         tridecal_t *decal;
12388         float frametime;
12389         float lifetime;
12390
12391         if (!decalsystem->numdecals)
12392                 return;
12393
12394         if (r_showsurfaces.integer)
12395                 return;
12396
12397         if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
12398         {
12399                 R_DecalSystem_Reset(decalsystem);
12400                 return;
12401         }
12402
12403         killsequence = cl.decalsequence - max(1, cl_decals_max.integer);
12404         lifetime = cl_decals_time.value + cl_decals_fadetime.value;
12405
12406         if (decalsystem->lastupdatetime)
12407                 frametime = (cl.time - decalsystem->lastupdatetime);
12408         else
12409                 frametime = 0;
12410         decalsystem->lastupdatetime = cl.time;
12411         decal = decalsystem->decals;
12412         numdecals = decalsystem->numdecals;
12413
12414         for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
12415         {
12416                 if (decal->color4ub[0][3])
12417                 {
12418                         decal->lived += frametime;
12419                         if (killsequence - decal->decalsequence > 0 || decal->lived >= lifetime)
12420                         {
12421                                 memset(decal, 0, sizeof(*decal));
12422                                 if (decalsystem->freedecal > i)
12423                                         decalsystem->freedecal = i;
12424                         }
12425                 }
12426         }
12427         decal = decalsystem->decals;
12428         while (numdecals > 0 && !decal[numdecals-1].color4ub[0][3])
12429                 numdecals--;
12430
12431         // collapse the array by shuffling the tail decals into the gaps
12432         for (;;)
12433         {
12434                 while (decalsystem->freedecal < numdecals && decal[decalsystem->freedecal].color4ub[0][3])
12435                         decalsystem->freedecal++;
12436                 if (decalsystem->freedecal == numdecals)
12437                         break;
12438                 decal[decalsystem->freedecal] = decal[--numdecals];
12439         }
12440
12441         decalsystem->numdecals = numdecals;
12442
12443         if (numdecals <= 0)
12444         {
12445                 // if there are no decals left, reset decalsystem
12446                 R_DecalSystem_Reset(decalsystem);
12447         }
12448 }
12449
12450 extern skinframe_t *decalskinframe;
12451 static void R_DrawModelDecals_Entity(entity_render_t *ent)
12452 {
12453         int i;
12454         decalsystem_t *decalsystem = &ent->decalsystem;
12455         int numdecals;
12456         tridecal_t *decal;
12457         float faderate;
12458         float alpha;
12459         float *v3f;
12460         float *c4f;
12461         float *t2f;
12462         const int *e;
12463         const unsigned char *surfacevisible = ent == r_refdef.scene.worldentity ? r_refdef.viewcache.world_surfacevisible : NULL;
12464         int numtris = 0;
12465
12466         numdecals = decalsystem->numdecals;
12467         if (!numdecals)
12468                 return;
12469
12470         if (r_showsurfaces.integer)
12471                 return;
12472
12473         if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
12474         {
12475                 R_DecalSystem_Reset(decalsystem);
12476                 return;
12477         }
12478
12479         // if the model is static it doesn't matter what value we give for
12480         // wantnormals and wanttangents, so this logic uses only rules applicable
12481         // to a model, knowing that they are meaningless otherwise
12482         if (ent == r_refdef.scene.worldentity)
12483                 RSurf_ActiveWorldEntity();
12484         else
12485                 RSurf_ActiveModelEntity(ent, false, false, false);
12486
12487         decalsystem->lastupdatetime = cl.time;
12488         decal = decalsystem->decals;
12489
12490         faderate = 1.0f / max(0.001f, cl_decals_fadetime.value);
12491
12492         // update vertex positions for animated models
12493         v3f = decalsystem->vertex3f;
12494         c4f = decalsystem->color4f;
12495         t2f = decalsystem->texcoord2f;
12496         for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
12497         {
12498                 if (!decal->color4ub[0][3])
12499                         continue;
12500
12501                 if (surfacevisible && !surfacevisible[decal->surfaceindex])
12502                         continue;
12503
12504                 // update color values for fading decals
12505                 if (decal->lived >= cl_decals_time.value)
12506                 {
12507                         alpha = 1 - faderate * (decal->lived - cl_decals_time.value);
12508                         alpha *= (1.0f/255.0f);
12509                 }
12510                 else
12511                         alpha = 1.0f/255.0f;
12512
12513                 c4f[ 0] = decal->color4ub[0][0] * alpha;
12514                 c4f[ 1] = decal->color4ub[0][1] * alpha;
12515                 c4f[ 2] = decal->color4ub[0][2] * alpha;
12516                 c4f[ 3] = 1;
12517                 c4f[ 4] = decal->color4ub[1][0] * alpha;
12518                 c4f[ 5] = decal->color4ub[1][1] * alpha;
12519                 c4f[ 6] = decal->color4ub[1][2] * alpha;
12520                 c4f[ 7] = 1;
12521                 c4f[ 8] = decal->color4ub[2][0] * alpha;
12522                 c4f[ 9] = decal->color4ub[2][1] * alpha;
12523                 c4f[10] = decal->color4ub[2][2] * alpha;
12524                 c4f[11] = 1;
12525
12526                 t2f[0] = decal->texcoord2f[0][0];
12527                 t2f[1] = decal->texcoord2f[0][1];
12528                 t2f[2] = decal->texcoord2f[1][0];
12529                 t2f[3] = decal->texcoord2f[1][1];
12530                 t2f[4] = decal->texcoord2f[2][0];
12531                 t2f[5] = decal->texcoord2f[2][1];
12532
12533                 // update vertex positions for animated models
12534                 if (decal->triangleindex >= 0 && decal->triangleindex < rsurface.modelnum_triangles)
12535                 {
12536                         e = rsurface.modelelement3i + 3*decal->triangleindex;
12537                         VectorCopy(rsurface.vertex3f + 3*e[0], v3f);
12538                         VectorCopy(rsurface.vertex3f + 3*e[1], v3f + 3);
12539                         VectorCopy(rsurface.vertex3f + 3*e[2], v3f + 6);
12540                 }
12541                 else
12542                 {
12543                         VectorCopy(decal->vertex3f[0], v3f);
12544                         VectorCopy(decal->vertex3f[1], v3f + 3);
12545                         VectorCopy(decal->vertex3f[2], v3f + 6);
12546                 }
12547
12548                 if (r_refdef.fogenabled)
12549                 {
12550                         alpha = RSurf_FogVertex(v3f);
12551                         VectorScale(c4f, alpha, c4f);
12552                         alpha = RSurf_FogVertex(v3f + 3);
12553                         VectorScale(c4f + 4, alpha, c4f + 4);
12554                         alpha = RSurf_FogVertex(v3f + 6);
12555                         VectorScale(c4f + 8, alpha, c4f + 8);
12556                 }
12557
12558                 v3f += 9;
12559                 c4f += 12;
12560                 t2f += 6;
12561                 numtris++;
12562         }
12563
12564         if (numtris > 0)
12565         {
12566                 r_refdef.stats.drawndecals += numtris;
12567
12568                 // now render the decals all at once
12569                 // (this assumes they all use one particle font texture!)
12570                 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);
12571                 R_Mesh_ResetTextureState();
12572                 R_Mesh_VertexPointer(decalsystem->vertex3f, 0, 0);
12573                 R_Mesh_TexCoordPointer(0, 2, decalsystem->texcoord2f, 0, 0);
12574                 R_Mesh_ColorPointer(decalsystem->color4f, 0, 0);
12575                 GL_DepthMask(false);
12576                 GL_DepthRange(0, 1);
12577                 GL_PolygonOffset(rsurface.basepolygonfactor + r_polygonoffset_decals_factor.value, rsurface.basepolygonoffset + r_polygonoffset_decals_offset.value);
12578                 GL_DepthTest(true);
12579                 GL_CullFace(GL_NONE);
12580                 GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
12581                 R_SetupShader_Generic(decalskinframe->base, NULL, GL_MODULATE, 1);
12582                 R_Mesh_Draw(0, numtris * 3, 0, numtris, decalsystem->element3i, decalsystem->element3s, 0, 0);
12583         }
12584 }
12585
12586 static void R_DrawModelDecals(void)
12587 {
12588         int i, numdecals;
12589
12590         // fade faster when there are too many decals
12591         numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
12592         for (i = 0;i < r_refdef.scene.numentities;i++)
12593                 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
12594
12595         R_DrawModelDecals_FadeEntity(r_refdef.scene.worldentity);
12596         for (i = 0;i < r_refdef.scene.numentities;i++)
12597                 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
12598                         R_DrawModelDecals_FadeEntity(r_refdef.scene.entities[i]);
12599
12600         R_DecalSystem_ApplySplatEntitiesQueue();
12601
12602         numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
12603         for (i = 0;i < r_refdef.scene.numentities;i++)
12604                 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
12605
12606         r_refdef.stats.totaldecals += numdecals;
12607
12608         if (r_showsurfaces.integer)
12609                 return;
12610
12611         R_DrawModelDecals_Entity(r_refdef.scene.worldentity);
12612
12613         for (i = 0;i < r_refdef.scene.numentities;i++)
12614         {
12615                 if (!r_refdef.viewcache.entityvisible[i])
12616                         continue;
12617                 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
12618                         R_DrawModelDecals_Entity(r_refdef.scene.entities[i]);
12619         }
12620 }
12621
12622 extern cvar_t mod_collision_bih;
12623 void R_DrawDebugModel(void)
12624 {
12625         entity_render_t *ent = rsurface.entity;
12626         int i, j, k, l, flagsmask;
12627         const msurface_t *surface;
12628         dp_model_t *model = ent->model;
12629         vec3_t v;
12630
12631         flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WALL;
12632
12633         R_Mesh_ColorPointer(NULL, 0, 0);
12634         R_Mesh_ResetTextureState();
12635         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
12636         GL_DepthRange(0, 1);
12637         GL_DepthTest(!r_showdisabledepthtest.integer);
12638         GL_DepthMask(false);
12639         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
12640
12641         if (r_showcollisionbrushes.value > 0 && model->collision_bih.numleafs)
12642         {
12643                 int triangleindex;
12644                 int bihleafindex;
12645                 qboolean cullbox = ent == r_refdef.scene.worldentity;
12646                 const q3mbrush_t *brush;
12647                 const bih_t *bih = &model->collision_bih;
12648                 const bih_leaf_t *bihleaf;
12649                 float vertex3f[3][3];
12650                 GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
12651                 cullbox = false;
12652                 for (bihleafindex = 0, bihleaf = bih->leafs;bihleafindex < bih->numleafs;bihleafindex++, bihleaf++)
12653                 {
12654                         if (cullbox && R_CullBox(bihleaf->mins, bihleaf->maxs))
12655                                 continue;
12656                         switch (bihleaf->type)
12657                         {
12658                         case BIH_BRUSH:
12659                                 brush = model->brush.data_brushes + bihleaf->itemindex;
12660                                 if (brush->colbrushf && brush->colbrushf->numtriangles)
12661                                 {
12662                                         R_Mesh_VertexPointer(brush->colbrushf->points->v, 0, 0);
12663                                         GL_Color((bihleafindex & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((bihleafindex >> 5) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((bihleafindex >> 10) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, r_showcollisionbrushes.value);
12664                                         R_Mesh_Draw(0, brush->colbrushf->numpoints, 0, brush->colbrushf->numtriangles, brush->colbrushf->elements, NULL, 0, 0);
12665                                 }
12666                                 break;
12667                         case BIH_COLLISIONTRIANGLE:
12668                                 triangleindex = bihleaf->itemindex;
12669                                 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+0], vertex3f[0]);
12670                                 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+1], vertex3f[1]);
12671                                 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+2], vertex3f[2]);
12672                                 R_Mesh_VertexPointer(vertex3f[0], 0, 0);
12673                                 GL_Color((bihleafindex & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((bihleafindex >> 5) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((bihleafindex >> 10) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, r_showcollisionbrushes.value);
12674                                 R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, polygonelement3s, 0, 0);
12675                                 break;
12676                         case BIH_RENDERTRIANGLE:
12677                                 triangleindex = bihleaf->itemindex;
12678                                 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+0], vertex3f[0]);
12679                                 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+1], vertex3f[1]);
12680                                 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+2], vertex3f[2]);
12681                                 R_Mesh_VertexPointer(vertex3f[0], 0, 0);
12682                                 GL_Color((bihleafindex & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((bihleafindex >> 5) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((bihleafindex >> 10) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, r_showcollisionbrushes.value);
12683                                 R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, polygonelement3s, 0, 0);
12684                                 break;
12685                         }
12686                 }
12687         }
12688
12689         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
12690
12691         if (r_showtris.integer || r_shownormals.integer)
12692         {
12693                 if (r_showdisabledepthtest.integer)
12694                 {
12695                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
12696                         GL_DepthMask(false);
12697                 }
12698                 else
12699                 {
12700                         GL_BlendFunc(GL_ONE, GL_ZERO);
12701                         GL_DepthMask(true);
12702                 }
12703                 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
12704                 {
12705                         if (ent == r_refdef.scene.worldentity && !r_refdef.viewcache.world_surfacevisible[j])
12706                                 continue;
12707                         rsurface.texture = R_GetCurrentTexture(surface->texture);
12708                         if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
12709                         {
12710                                 RSurf_PrepareVerticesForBatch(true, true, 1, &surface);
12711                                 if (r_showtris.value > 0)
12712                                 {
12713                                         if (!rsurface.texture->currentlayers->depthmask)
12714                                                 GL_Color(r_refdef.view.colorscale, 0, 0, r_showtris.value);
12715                                         else if (ent == r_refdef.scene.worldentity)
12716                                                 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, r_showtris.value);
12717                                         else
12718                                                 GL_Color(0, r_refdef.view.colorscale, 0, r_showtris.value);
12719                                         R_Mesh_VertexPointer(rsurface.vertex3f, 0, 0);
12720                                         R_Mesh_ColorPointer(NULL, 0, 0);
12721                                         R_Mesh_TexCoordPointer(0, 0, NULL, 0, 0);
12722                                         qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
12723                                         //R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, model->surfmesh.data_element3i, NULL, 0, 0);
12724                                         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);
12725                                         qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
12726                                         CHECKGLERROR
12727                                 }
12728                                 if (r_shownormals.value < 0)
12729                                 {
12730                                         qglBegin(GL_LINES);
12731                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
12732                                         {
12733                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
12734                                                 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
12735                                                 qglVertex3f(v[0], v[1], v[2]);
12736                                                 VectorMA(v, -r_shownormals.value, rsurface.svector3f + l * 3, v);
12737                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
12738                                                 qglVertex3f(v[0], v[1], v[2]);
12739                                         }
12740                                         qglEnd();
12741                                         CHECKGLERROR
12742                                 }
12743                                 if (r_shownormals.value > 0)
12744                                 {
12745                                         qglBegin(GL_LINES);
12746                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
12747                                         {
12748                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
12749                                                 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
12750                                                 qglVertex3f(v[0], v[1], v[2]);
12751                                                 VectorMA(v, r_shownormals.value, rsurface.svector3f + l * 3, v);
12752                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
12753                                                 qglVertex3f(v[0], v[1], v[2]);
12754                                         }
12755                                         qglEnd();
12756                                         CHECKGLERROR
12757                                         qglBegin(GL_LINES);
12758                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
12759                                         {
12760                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
12761                                                 GL_Color(0, r_refdef.view.colorscale, 0, 1);
12762                                                 qglVertex3f(v[0], v[1], v[2]);
12763                                                 VectorMA(v, r_shownormals.value, rsurface.tvector3f + l * 3, v);
12764                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
12765                                                 qglVertex3f(v[0], v[1], v[2]);
12766                                         }
12767                                         qglEnd();
12768                                         CHECKGLERROR
12769                                         qglBegin(GL_LINES);
12770                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
12771                                         {
12772                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
12773                                                 GL_Color(0, 0, r_refdef.view.colorscale, 1);
12774                                                 qglVertex3f(v[0], v[1], v[2]);
12775                                                 VectorMA(v, r_shownormals.value, rsurface.normal3f + l * 3, v);
12776                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
12777                                                 qglVertex3f(v[0], v[1], v[2]);
12778                                         }
12779                                         qglEnd();
12780                                         CHECKGLERROR
12781                                 }
12782                         }
12783                 }
12784                 rsurface.texture = NULL;
12785         }
12786 }
12787
12788 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
12789 int r_maxsurfacelist = 0;
12790 const msurface_t **r_surfacelist = NULL;
12791 void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
12792 {
12793         int i, j, endj, flagsmask;
12794         dp_model_t *model = r_refdef.scene.worldmodel;
12795         msurface_t *surfaces;
12796         unsigned char *update;
12797         int numsurfacelist = 0;
12798         if (model == NULL)
12799                 return;
12800
12801         if (r_maxsurfacelist < model->num_surfaces)
12802         {
12803                 r_maxsurfacelist = model->num_surfaces;
12804                 if (r_surfacelist)
12805                         Mem_Free((msurface_t**)r_surfacelist);
12806                 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
12807         }
12808
12809         RSurf_ActiveWorldEntity();
12810
12811         surfaces = model->data_surfaces;
12812         update = model->brushq1.lightmapupdateflags;
12813
12814         // update light styles on this submodel
12815         if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
12816         {
12817                 model_brush_lightstyleinfo_t *style;
12818                 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
12819                 {
12820                         if (style->value != r_refdef.scene.lightstylevalue[style->style])
12821                         {
12822                                 int *list = style->surfacelist;
12823                                 style->value = r_refdef.scene.lightstylevalue[style->style];
12824                                 for (j = 0;j < style->numsurfaces;j++)
12825                                         update[list[j]] = true;
12826                         }
12827                 }
12828         }
12829
12830         flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
12831
12832         if (debug)
12833         {
12834                 R_DrawDebugModel();
12835                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
12836                 return;
12837         }
12838
12839         rsurface.uselightmaptexture = false;
12840         rsurface.texture = NULL;
12841         rsurface.rtlight = NULL;
12842         numsurfacelist = 0;
12843         // add visible surfaces to draw list
12844         for (i = 0;i < model->nummodelsurfaces;i++)
12845         {
12846                 j = model->sortedmodelsurfaces[i];
12847                 if (r_refdef.viewcache.world_surfacevisible[j])
12848                         r_surfacelist[numsurfacelist++] = surfaces + j;
12849         }
12850         // update lightmaps if needed
12851         if (model->brushq1.firstrender)
12852         {
12853                 model->brushq1.firstrender = false;
12854                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
12855                         if (update[j])
12856                                 R_BuildLightMap(r_refdef.scene.worldentity, surfaces + j);
12857         }
12858         else if (update)
12859         {
12860                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
12861                         if (r_refdef.viewcache.world_surfacevisible[j])
12862                                 if (update[j])
12863                                         R_BuildLightMap(r_refdef.scene.worldentity, surfaces + j);
12864         }
12865         // don't do anything if there were no surfaces
12866         if (!numsurfacelist)
12867         {
12868                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
12869                 return;
12870         }
12871         R_QueueWorldSurfaceList(numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
12872         GL_AlphaTest(false);
12873
12874         // add to stats if desired
12875         if (r_speeds.integer && !skysurfaces && !depthonly)
12876         {
12877                 r_refdef.stats.world_surfaces += numsurfacelist;
12878                 for (j = 0;j < numsurfacelist;j++)
12879                         r_refdef.stats.world_triangles += r_surfacelist[j]->num_triangles;
12880         }
12881
12882         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
12883 }
12884
12885 void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
12886 {
12887         int i, j, endj, flagsmask;
12888         dp_model_t *model = ent->model;
12889         msurface_t *surfaces;
12890         unsigned char *update;
12891         int numsurfacelist = 0;
12892         if (model == NULL)
12893                 return;
12894
12895         if (r_maxsurfacelist < model->num_surfaces)
12896         {
12897                 r_maxsurfacelist = model->num_surfaces;
12898                 if (r_surfacelist)
12899                         Mem_Free((msurface_t **)r_surfacelist);
12900                 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
12901         }
12902
12903         // if the model is static it doesn't matter what value we give for
12904         // wantnormals and wanttangents, so this logic uses only rules applicable
12905         // to a model, knowing that they are meaningless otherwise
12906         if (ent == r_refdef.scene.worldentity)
12907                 RSurf_ActiveWorldEntity();
12908         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
12909                 RSurf_ActiveModelEntity(ent, false, false, false);
12910         else if (prepass)
12911                 RSurf_ActiveModelEntity(ent, true, true, true);
12912         else if (depthonly)
12913         {
12914                 switch (vid.renderpath)
12915                 {
12916                 case RENDERPATH_GL20:
12917                 case RENDERPATH_CGGL:
12918                         RSurf_ActiveModelEntity(ent, model->wantnormals, model->wanttangents, false);
12919                         break;
12920                 case RENDERPATH_GL13:
12921                 case RENDERPATH_GL11:
12922                         RSurf_ActiveModelEntity(ent, model->wantnormals, false, false);
12923                         break;
12924                 }
12925         }
12926         else
12927         {
12928                 switch (vid.renderpath)
12929                 {
12930                 case RENDERPATH_GL20:
12931                 case RENDERPATH_CGGL:
12932                         RSurf_ActiveModelEntity(ent, true, true, false);
12933                         break;
12934                 case RENDERPATH_GL13:
12935                 case RENDERPATH_GL11:
12936                         RSurf_ActiveModelEntity(ent, true, false, false);
12937                         break;
12938                 }
12939         }
12940
12941         surfaces = model->data_surfaces;
12942         update = model->brushq1.lightmapupdateflags;
12943
12944         // update light styles
12945         if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
12946         {
12947                 model_brush_lightstyleinfo_t *style;
12948                 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
12949                 {
12950                         if (style->value != r_refdef.scene.lightstylevalue[style->style])
12951                         {
12952                                 int *list = style->surfacelist;
12953                                 style->value = r_refdef.scene.lightstylevalue[style->style];
12954                                 for (j = 0;j < style->numsurfaces;j++)
12955                                         update[list[j]] = true;
12956                         }
12957                 }
12958         }
12959
12960         flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
12961
12962         if (debug)
12963         {
12964                 R_DrawDebugModel();
12965                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
12966                 return;
12967         }
12968
12969         rsurface.uselightmaptexture = false;
12970         rsurface.texture = NULL;
12971         rsurface.rtlight = NULL;
12972         numsurfacelist = 0;
12973         // add visible surfaces to draw list
12974         for (i = 0;i < model->nummodelsurfaces;i++)
12975                 r_surfacelist[numsurfacelist++] = surfaces + model->sortedmodelsurfaces[i];
12976         // don't do anything if there were no surfaces
12977         if (!numsurfacelist)
12978         {
12979                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
12980                 return;
12981         }
12982         // update lightmaps if needed
12983         if (update)
12984         {
12985                 int updated = 0;
12986                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
12987                 {
12988                         if (update[j])
12989                         {
12990                                 updated++;
12991                                 R_BuildLightMap(ent, surfaces + j);
12992                         }
12993                 }
12994         }
12995         if (update)
12996                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
12997                         if (update[j])
12998                                 R_BuildLightMap(ent, surfaces + j);
12999         R_QueueModelSurfaceList(ent, numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
13000         GL_AlphaTest(false);
13001
13002         // add to stats if desired
13003         if (r_speeds.integer && !skysurfaces && !depthonly)
13004         {
13005                 r_refdef.stats.entities_surfaces += numsurfacelist;
13006                 for (j = 0;j < numsurfacelist;j++)
13007                         r_refdef.stats.entities_triangles += r_surfacelist[j]->num_triangles;
13008         }
13009
13010         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
13011 }
13012
13013 void R_DrawCustomSurface(skinframe_t *skinframe, const matrix4x4_t *texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qboolean writedepth, qboolean prepass)
13014 {
13015         static texture_t texture;
13016         static msurface_t surface;
13017         const msurface_t *surfacelist = &surface;
13018
13019         // fake enough texture and surface state to render this geometry
13020
13021         texture.update_lastrenderframe = -1; // regenerate this texture
13022         texture.basematerialflags = materialflags | MATERIALFLAG_CUSTOMSURFACE | MATERIALFLAG_WALL;
13023         texture.currentskinframe = skinframe;
13024         texture.currenttexmatrix = *texmatrix; // requires MATERIALFLAG_CUSTOMSURFACE
13025         texture.offsetmapping = OFFSETMAPPING_OFF;
13026         texture.offsetscale = 1;
13027         texture.specularscalemod = 1;
13028         texture.specularpowermod = 1;
13029
13030         surface.texture = &texture;
13031         surface.num_triangles = numtriangles;
13032         surface.num_firsttriangle = firsttriangle;
13033         surface.num_vertices = numvertices;
13034         surface.num_firstvertex = firstvertex;
13035
13036         // now render it
13037         rsurface.texture = R_GetCurrentTexture(surface.texture);
13038         rsurface.uselightmaptexture = false;
13039         R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
13040 }
13041
13042 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)
13043 {
13044         static msurface_t surface;
13045         const msurface_t *surfacelist = &surface;
13046
13047         // fake enough texture and surface state to render this geometry
13048
13049         surface.texture = texture;
13050         surface.num_triangles = numtriangles;
13051         surface.num_firsttriangle = firsttriangle;
13052         surface.num_vertices = numvertices;
13053         surface.num_firstvertex = firstvertex;
13054
13055         // now render it
13056         rsurface.texture = R_GetCurrentTexture(surface.texture);
13057         rsurface.uselightmaptexture = false;
13058         R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
13059 }